Index

Modules: libp2p, libp2p/autotls/acme/api, libp2p/autotls/acme/client, libp2p/autotls/acme/jws, libp2p/autotls/acme/utils, libp2p/autotls/broker, 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/rng, libp2p/crypto/rsa, libp2p/crypto/secp, libp2p/dial, libp2p/dialer, libp2p/errors, libp2p/multiaddress, libp2p/multibase, libp2p/multicodec, libp2p/multihash, libp2p/multistream, libp2p/muxer_store, libp2p/muxers/mplex/coder, libp2p/muxers/mplex/lpchannel, libp2p/muxers/mplex/mplex, libp2p/muxers/muxer, libp2p/muxers/yamux/yamux, libp2p/nameresolving/dnsmessage, libp2p/nameresolving/dnsresolver, libp2p/nameresolving/nameresolver, libp2p/observedaddrmanager, libp2p/peeraddrpolicy, libp2p/peerid, libp2p/peeridauth/client, libp2p/peerinfo, libp2p/peerstore, libp2p/protobuf/minprotobuf, libp2p/protocols/connectivity/autonat/client, libp2p/protocols/connectivity/autonat/server, libp2p/protocols/connectivity/autonat/service, 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/dcutr/client, libp2p/protocols/connectivity/dcutr/core, libp2p/protocols/connectivity/dcutr/server, 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/kademlia_metrics, libp2p/protocols/kademlia/ping, libp2p/protocols/kademlia/protobuf, libp2p/protocols/kademlia/provider, libp2p/protocols/kademlia/put, libp2p/protocols/kademlia/routing_table, libp2p/protocols/kademlia/types, libp2p/protocols/ping, libp2p/protocols/protocol, libp2p/protocols/pubsub, libp2p/protocols/pubsub/errors, libp2p/protocols/pubsub/floodsub, libp2p/protocols/pubsub/gossipsub, libp2p/protocols/pubsub/gossipsub/bandwidth, libp2p/protocols/pubsub/gossipsub/behavior, libp2p/protocols/pubsub/gossipsub/extension_partial_message, libp2p/protocols/pubsub/gossipsub/extension_pingpong, libp2p/protocols/pubsub/gossipsub/extension_preamble, libp2p/protocols/pubsub/gossipsub/extension_test, libp2p/protocols/pubsub/gossipsub/extensions, libp2p/protocols/pubsub/gossipsub/extensions_types, libp2p/protocols/pubsub/gossipsub/partial_message, 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/autorelayservice, libp2p/services/hpservice, libp2p/services/identify_pusher, libp2p/services/nat/natpmp_mapper, libp2p/services/nat/portmapper, libp2p/services/nat/upnp_mapper, libp2p/services/natservice, 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/utils/bytesview, libp2p/utils/collections, libp2p/utils/conversion, libp2p/utils/future, libp2p/utils/heartbeat, libp2p/utils/ipaddr, libp2p/utils/lock, libp2p/utils/macroutils, libp2p/utils/offsettedseq, libp2p/utils/opt, libp2p/utils/protobuf, libp2p/utils/protobuf_chronos_sec, libp2p/utils/shortlog, libp2p/utils/tablekey, 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
• routing_table: proc `$`(rt: RoutingTable): string
• partial_message: proc `$`(g: GroupId): 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

`<`:

• multiaddress: proc `<`(a, b: MultiAddress): 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
• protobuf: proc `==`(a, b: Peer): 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 `[]=`(addressBook: AddressBook; peerId: PeerId; addrs: seq[MultiAddress])
• peerstore: proc `[]=`[T](peerBook: PeerBook[T]; peerId: PeerId; entry: T)

`[]`:

• 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 `[]`(addressBook: AddressBook; peerId: PeerId): seq[MultiAddress]
• peerstore: proc `[]`[T](peerBook: PeerBook[T]; peerId: PeerId): T
• peerstore: proc `[]`(p: PeerStore; _: type[AddressBook]): AddressBook
• peerstore: proc `[]`[T](p: PeerStore; typ: type[T]): T
• provider: proc `[]`(pr: ProviderRecords; i: int): ProviderRecord
• preamblestore: proc `[]`(ps: PreambleStore; msgId: MessageId): PreambleInfo
• offsettedseq: proc `[]`[T](o: var OffsettedSeq[T]; index: int): var T

A:

• dnsmessage: DnsRecordKind.A

AAAA:

• dnsmessage: DnsRecordKind.AAAA

accept:

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

accepted:

• protobuf: AddProviderStatus.accepted

accepts:

• peeraddrpolicy: proc accepts(policy: PeerAddressPolicy; ma: MultiAddress): bool

ACMEApi:

• api: type ACMEApi

ACMEAuthorizationsResponse:

• api: object ACMEAuthorizationsResponse

ACMECertificate:

• api: object ACMECertificate

ACMECertificateResponse:

• api: object ACMECertificateResponse

ACMEChallenge:

• api: object ACMEChallenge

ACMEChallengeCheck:

• api: ACMECheckKind.ACMEChallengeCheck

ACMEChallengeDns01Response:

• api: object ACMEChallengeDns01Response

ACMEChallengeResponse:

• api: object ACMEChallengeResponse

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

ACMENetworkError:

• utils: object ACMENetworkError

ACMEOrderCheck:

• api: ACMECheckKind.ACMEOrderCheck

ACMEOrderResponse:

• api: object ACMEOrderResponse

ACMEOrderStatus:

• api: enum ACMEOrderStatus

ACMERegisterRequest:

• api: object ACMERegisterRequest

ACMERegisterResponse:

• api: object ACMERegisterResponse

add:

• muxer_store: proc add(s: MuxerStore; muxer: Muxer): bool
• switch: proc add(s: Switch; service: Service)
• 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; protocol: LPProtocol; matcher: Matcher = nil)
• multistream: proc addHandler[E](m: MultistreamSelect; codec: string; handler: LPProtoHandler | proc (stream: Stream; proto: string): InternalRaisesFuture[void, E]; matcher: Matcher = nil)
• peerstore: proc addHandler[T](peerBook: PeerBook[T]; handler: PeerBookChangeHandler)

addObservation:

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

addObserver:

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

addPeer:

• extensions: proc addPeer(state: ExtensionsState; peerId: PeerId)
• 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; peerId: PeerId)

addProvider:

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

AddProviderStatus:

• protobuf: enum AddProviderStatus

AddressBook:

• peerstore: type AddressBook

AddressConfidence:

• peerstore: enum AddressConfidence

AddressConfidenceTtls:

• peerstore: object AddressConfidenceTtls

AddressEntry:

• peerstore: object AddressEntry

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

allFuturesWaitOrTimeout:

• future: proc allFuturesWaitOrTimeout[Fut](futs: seq[Fut]; timeout: Duration): InternalRaisesFuture[ void, (CancelledError,)]

allKeys:

• routing_table: proc allKeys(bucket: Bucket): seq[Key]
• routing_table: proc allKeys(rtable: RoutingTable): seq[Key]

allSortedPeers:

• find: proc allSortedPeers(state: LookupState): seq[PeerId]

AlreadyExpectingConnectionError:

• connmanager: object AlreadyExpectingConnectionError

And:

• multiaddress: MaPatternOp.And

anonymize:

• messages: proc anonymize(msg: Message; anonymize: bool): Message
• messages: proc anonymize(msg: RPCMsg; anonymize: bool): RPCMsg

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

asMoment:

• utils: proc asMoment(dt: DateTime): Moment

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

AutonatClient:

• client: type AutonatClient

AutonatCodec:

• types: const AutonatCodec

autonatConfig:

• natservice: proc autonatConfig(version: AutonatVersion; scheduleInterval = Opt.none(Duration); v2ServiceConfig = Opt.none(AutonatV2ServiceConfig)): NATConfig

AutonatDial:

• types: object AutonatDial

AutonatDialResponse:

• types: object AutonatDialResponse

AutonatError:

• types: object AutonatError

AutonatMsg:

• types: object AutonatMsg

AutonatPeerInfo:

• types: object AutonatPeerInfo

AutonatService:

• service: type AutonatService

AutonatUnreachableError:

• types: object AutonatUnreachableError

AutonatV1:

• natservice: AutonatVersion.AutonatV1

AutonatV2:

• server: type AutonatV2
• natservice: AutonatVersion.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

AutonatV2MsgOneof:

• types: object AutonatV2MsgOneof

AutonatV2Response:

• types: object AutonatV2Response

AutonatV2Service:

• service: type AutonatV2Service

autonatV2Service:

• natservice: proc autonatV2Service(self: NATService): Opt[AutonatV2Service]

AutonatV2ServiceConfig:

• service: object AutonatV2ServiceConfig

AutonatVersion:

• natservice: enum AutonatVersion

AutoRelayService:

• autorelayservice: type AutoRelayService

AutotlsBroker:

• broker: type AutotlsBroker

AutotlsCert:

• service: type AutotlsCert

AutotlsConfig:

• service: object AutotlsConfig

AutoTLSDNSServer:

• service: const AutoTLSDNSServer

AutoTLSError:

• utils: object AutoTLSError

AutotlsService:

• service: type AutotlsService

availableSlots:

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

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

base64UrlEncode:

• utils: proc base64UrlEncode(data: seq[byte]): string

BasePrecomp:

• constants: const BasePrecomp

BearerToken:

• client: object BearerToken

bearSslDrbg:

• rng: template bearSslDrbg(rng: Rng): untyped

bearSslDrbgRef:

• rng: template bearSslDrbgRef(rng: Rng): untyped

bearSslPrng:

• rng: template bearSslPrng(rng: Rng): untyped

bioToSeq:

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

BiPrecomp:

• constants: const BiPrecomp

bootstrap:

• kademlia: proc bootstrap(kad: KadDHT; forceRefresh = false): InternalRaisesFuture[void, (CancelledError,)]

bridge:

• utils: proc bridge(srcStream: Stream; dstStream: Stream): InternalRaisesFuture[void, (CancelledError,)]

bridgedConnections:

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

BridgeStream:

• bridgestream: type BridgeStream

broadcast:

• pubsub: proc broadcast(p: PubSub; sendPeers: auto; msg: RPCMsg; priority: MessagePriority; useCustomStream: bool = false)

Bucket:

• types: object Bucket

bucketIndex:

• routing_table: proc bucketIndex(rtable: RoutingTable; key: Key): int

BufferStream:

• bufferstream: type BufferStream

BufferStreamTrackerName:

• bufferstream: const BufferStreamTrackerName

build:

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

bumpDecayingTag:

• connmanager: proc bumpDecayingTag(c: ConnManager; peerId: PeerId; tag: string; delta: int)

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(iwants: seq[ControlIWant]): int
• messages: proc byteSize(imreceivings: seq[IMReceiving]): int
• messages: proc byteSize(msgs: seq[Message]): int
• messages: proc byteSize(preambles: seq[Preamble]): int

BytesView:

• bytesview: object BytesView

CacheEntry:

• mcache: object CacheEntry

calculateReceiveTimeMs:

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

canAcceptIncoming:

• protocol: proc canAcceptIncoming(p: LPProtocol; peerId: PeerId): bool

canAskIWant:

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

cancelAndWait:

• future: template cancelAndWait[T](futs: seq[T]): auto

cancelSoon:

• future: template cancelSoon[T](futs: seq[T])

canConnect:

• protobuf: ConnectionStatus.canConnect

CandidatePeers:

• types: type CandidatePeers

cannotConnect:

• protobuf: ConnectionStatus.cannotConnect

canOpenOutgoing:

• protocol: proc canOpenOutgoing(p: LPProtocol; peerId: PeerId): bool

canStoreLocalRecord:

• put: proc canStoreLocalRecord(kad: KadDHT; key: Key): bool

capLen:

• collections: proc capLen[T](s: var seq[T]; length: int)

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

certificateFinalized:

• api: proc certificateFinalized(self: ACMEApi; domain: Domain; finalize: Uri; order: Uri; certKeyPair: RsaPrivateKey; key: RsaPrivateKey; kid: Kid; retries: int = DefaultFinalizeRetries): InternalRaisesFuture[ bool, (ACMEError, CancelledError)]

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

checkAddresses:

• routing_record: proc checkAddresses(addresses: seq[AddressInfo]): Result[void, string]

checkCertFinalized:

• api: proc checkCertFinalized(self: ACMEApi; order: Uri; key: RsaPrivateKey; kid: Kid; retries: int = DefaultChalCompletedRetries): InternalRaisesFuture[ bool, (ACMEError, CancelledError)]

checkChallengeCompleted:

• api: proc checkChallengeCompleted(self: ACMEApi; checkURL: Uri; key: RsaPrivateKey; kid: Kid; retries: int = DefaultChalCompletedRetries): InternalRaisesFuture[ bool, (ACMEError, CancelledError)]

checkDNSRecords:

• utils: proc checkDNSRecords(nameResolver: NameResolver; ipAddress: IpAddress; baseDomain: api.Domain; keyAuth: KeyAuthorization; retries: int = DefaultDnsRetries; retryTime: Duration = DefaultDnsRetryTime): InternalRaisesFuture[ bool, (AutoTLSError, CancelledError)]

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]

chroniclesExpandItIMPL:

• identify: template chroniclesExpandItIMPL(record: auto; it_name: static string; it: IdentifyMsg)
• identify: template chroniclesExpandItIMPL[RecordType: tuple](record: RecordType; it_name: static string; it: IdentifyMsg; enabled: auto)

chroniclesFormatItIMPL:

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

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)
• muxer_store: proc clear(s: MuxerStore)
• zeroqueue: proc clear(q: var ZeroQueue)

close:

• api: proc close(self: ACMEApi): InternalRaisesFuture[void, (CancelledError,)]
• client: proc close(self: ACMEClient): InternalRaisesFuture[void, (CancelledError,)]
• broker: proc close(self: AutotlsBroker): InternalRaisesFuture[void, (CancelledError,)]
• 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,)]
• peerstore: proc close(peerStore: PeerStore)
• natpmp_mapper: method close(self: NatPmpMapper): InternalRaisesFuture[void, void]
• portmapper: method close(self: PortMapper): InternalRaisesFuture[void, void]
• upnp_mapper: method close(self: UpnpMapper): InternalRaisesFuture[void, void]
• 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]

closestAvailableStop:

• find: proc closestAvailableStop(state: LookupState): bool

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:

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

compilesOr:

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

completeChallenge:

• api: proc completeChallenge(self: ACMEApi; chalURL: Uri; key: RsaPrivateKey; kid: Kid; retries: int = DefaultChalCompletedRetries): InternalRaisesFuture[ bool, (ACMEError, CancelledError)]

completeOnce:

• future: template completeOnce(fut: auto)
• future: template completeOnce(fut: auto; val: auto)

computeFieldSize:

• crypto: proc computeFieldSize(field: int; value: PublicKey; ProtoType: type ProtobufExt; skipDefault: static bool): int
• crypto: proc computeFieldSize(field: int; value: Signature; ProtoType: type ProtobufExt; skipDefault: static bool): int
• multiaddress: proc computeFieldSize(field`gensym544: int; value`gensym544: seq[MultiAddress]; ProtoType`gensym544: type ProtobufExt; skipDefault`gensym544: static bool): int
• multiaddress: proc computeFieldSize(field: int; value: MultiAddress; ProtoType: type ProtobufExt; skipDefault: static bool): int
• peerid: proc computeFieldSize(field`gensym100: int; value`gensym100: seq[PeerId]; ProtoType`gensym100: type ProtobufExt; skipDefault`gensym100: static bool): int
• peerid: proc computeFieldSize(field: int; value: PeerId; ProtoType: type ProtobufExt; skipDefault: static bool): int
• protobuf_chronos_sec: proc computeFieldSize(field`gensym1: int; value`gensym1: seq[Duration]; ProtoType`gensym1: type ProtobufExt; skipDefault`gensym1: static bool): int
• protobuf_chronos_sec: proc computeFieldSize(field`gensym3: int; value`gensym3: seq[Moment]; ProtoType`gensym3: type ProtobufExt; skipDefault`gensym3: static bool): int
• protobuf_chronos_sec: proc computeFieldSize(field: int; value: Duration; ProtoType: type ProtobufExt; skipDefault: static bool): int
• protobuf_chronos_sec: proc computeFieldSize(field: int; value: Moment; ProtoType: type ProtobufExt; skipDefault: static bool): int

computeFieldSizePacked:

• protobuf_chronos_sec: proc computeFieldSizePacked(field: int; value: seq[Duration]; ProtoType: type ProtobufExt): int
• protobuf_chronos_sec: proc computeFieldSizePacked(field: int; value: seq[Moment]; ProtoType: type ProtobufExt): int

concat:

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

ConcurrentUpgrades:

• switch: const ConcurrentUpgrades

Confirmed:

• protobuf: RegistrationStatus.Confirmed

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: ConnectionStatus.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

ConnectionLimits:

• connmanager: object ConnectionLimits

ConnectionSlot:

• connmanager: object ConnectionSlot

ConnectionStatus:

• protobuf: enum ConnectionStatus

ConnectionTrackerName:

• connection: const ConnectionTrackerName

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): RawConn

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]
• muxer_store: proc contains(s: MuxerStore; muxer: Muxer): bool
• muxer_store: proc contains(s: MuxerStore; peerId: PeerId): bool
• peerstore: proc contains(addressBook: AddressBook; peerId: PeerId): 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]

ControlExtensions:

• messages: object ControlExtensions

ControlGraft:

• messages: object ControlGraft

ControlIHave:

• messages: object ControlIHave

ControlIWant:

• messages: object ControlIWant

ControlMessage:

• messages: object ControlMessage

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:

• muxer_store: proc count(s: MuxerStore; peerId: PeerId): int
• offsettedseq: proc count[T](o: OffsettedSeq[T]; x: T): int

countLeadingZeroBits:

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

countPeers:

• muxer_store: proc countPeers(s: MuxerStore): int

countRegister:

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

createCSR:

• utils: proc createCSR(domain: string; certKeyPair: RsaPrivateKey): string

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: StreamCallback2; 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

CustomPeerSelectionProc:

• pubsubpeer: type CustomPeerSelectionProc

CustomStreamCallbacks:

• pubsubpeer: object CustomStreamCallbacks

CustomStreamCreationProc:

• pubsubpeer: type CustomStreamCreationProc

D2Const:

• constants: const D2Const

data:

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

DConst:

• constants: const DConst

Dcutr:

• server: type Dcutr

DcutrClient:

• client: type DcutrClient

DcutrCodec:

• core: const DcutrCodec

DcutrError:

• core: object DcutrError

DcutrMsg:

• core: object DcutrMsg

decayFixed:

• connmanager: proc decayFixed(amount: int): DecayFn

DecayFn:

• connmanager: type DecayFn

decayLinear:

• connmanager: proc decayLinear(coef: float): DecayFn

decayNone:

• connmanager: proc decayNone(): DecayFn

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(_: type AutonatMsg; buf`gensym2: seq[byte]): Result[AutonatMsg, string]
• types: proc decode(_: type AutonatV2Msg; buf`gensym99: seq[byte]): Result[AutonatV2Msg, string]
• types: proc decode(_: type DialBack; buf`gensym0: seq[byte]): Result[DialBack, string]
• types: proc decode(_: type DialBackResponse; buf`gensym1: seq[byte]): Result[ DialBackResponse, string]
• core: proc decode(_: type DcutrMsg; buf`gensym0: seq[byte]): Result[DcutrMsg, string]
• messages: proc decode(_: type HopMessage; buf`gensym446: seq[byte]): Result[HopMessage, string]
• messages: proc decode(_: type RelayMessage; buf`gensym0: seq[byte]): Result[RelayMessage, string]
• messages: proc decode(_: type StopMessage; buf`gensym445: seq[byte]): Result[StopMessage, string]
• messages: proc decode(_: type Voucher; buf`gensym290: seq[byte]): Result[Voucher, string]
• identify: proc decode(_: type IdentifyMsg; buf`gensym2: seq[byte]): Result[IdentifyMsg, string]
• protobuf: proc decode(_: type Message; buf`gensym241: seq[byte]): Result[Message, string]
• protobuf: proc decode(_: type Peer; buf`gensym155: seq[byte]): Result[Peer, string]
• protobuf: proc decode(_: type Record; buf`gensym2: seq[byte]): Result[Record, string]
• protobuf: proc decode(_: type Message; buf: seq[byte]): Result[Message, string]
• protobuf: proc decode(_: type RPCMsg; buf: seq[byte]): Result[RPCMsg, string]
• protobuf: proc decode(_: type Cookie; buf`gensym0: seq[byte]): Result[Cookie, string]
• protobuf: proc decode(_: type Discover; buf`gensym4: seq[byte]): Result[Discover, string]
• protobuf: proc decode(_: type DiscoverResponse; buf`gensym5: seq[byte]): Result[ DiscoverResponse, string]
• protobuf: proc decode(_: type Message; buf`gensym690: seq[byte]): Result[Message, string]
• protobuf: proc decode(_: type Register; buf`gensym1: seq[byte]): Result[Register, string]
• protobuf: proc decode(_: type RegisterResponse; buf`gensym2: seq[byte]): Result[ RegisterResponse, string]
• protobuf: proc decode(_: type Unregister; buf`gensym3: seq[byte]): Result[Unregister, string]
• noise: proc decode(_: type NoiseHandshakePayloadMsg; buf`gensym2: seq[byte]): Result[ NoiseHandshakePayloadMsg, string]
• routing_record: proc decode(_: type PeerRecord; buf`gensym6: seq[byte]): Result[PeerRecord, string]
• signed_envelope: proc decode[T](_: typedesc[SignedPayload[T]]; envelope: Envelope): Result[ SignedPayload[T], EnvelopeError]
• signed_envelope: proc decode[T](_: typedesc[SignedPayload[T]]; buffer: sink seq[byte]): Result[ SignedPayload[T], EnvelopeError]
• signed_envelope: proc decode(_: type Envelope; buf: seq[byte]; domain: string): Result[Envelope, EnvelopeError]

decodedLength:

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

decodeFor:

• protobuf: macro decodeFor(_: type Protobuf; Types: untyped; withMetrics: bool = false; domain: string = ""): untyped

decrypt:

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

defaultAddressPolicy:

• peeraddrpolicy: const defaultAddressPolicy

DefaultAlpha:

• types: const DefaultAlpha

DefaultAmplificationAttackDialTimeout:

• types: const DefaultAmplificationAttackDialTimeout

DefaultBrokerURL:

• broker: const DefaultBrokerURL

DefaultBucketRefreshTime:

• types: const DefaultBucketRefreshTime

DefaultBucketStaleTime:

• types: const DefaultBucketStaleTime

DefaultChanTimeout:

• muxer: const DefaultChanTimeout

DefaultCleanupDataEntriesInterval:

• types: const DefaultCleanupDataEntriesInterval

DefaultCleanupProvidersInterval:

• types: const DefaultCleanupProvidersInterval

DefaultConnectionTimeout:

• connection: const DefaultConnectionTimeout

DefaultDialBackTimeout:

• client: const DefaultDialBackTimeout

DefaultDialDataSize:

• types: const DefaultDialDataSize

DefaultDialTimeout:

• types: const DefaultDialTimeout

DefaultDiscoveryTimeout:

• natservice: const DefaultDiscoveryTimeout

DefaultDnsServers:

• dnsresolver: const DefaultDnsServers

DefaultEntrySelector:

• types: type DefaultEntrySelector

DefaultEntryValidator:

• types: type DefaultEntryValidator

DefaultHeartbeatSleepTime:

• relay: const DefaultHeartbeatSleepTime

DefaultKeySize:

• rsa: const DefaultKeySize

DefaultLeaseDuration:

• natservice: const DefaultLeaseDuration

DefaultLimitData:

• relay: const DefaultLimitData

DefaultLimitDuration:

• relay: const DefaultLimitDuration

DefaultMaxBuckets:

• types: const DefaultMaxBuckets

DefaultMaxConcurrentRpcs:

• types: const DefaultMaxConcurrentRpcs

DefaultMaxHighPriorityQueueLen:

• pubsubpeer: const DefaultMaxHighPriorityQueueLen

DefaultMaxLocalRecords:

• types: const DefaultMaxLocalRecords

DefaultMaxLowPriorityQueueLen:

• pubsubpeer: const DefaultMaxLowPriorityQueueLen

DefaultMaxMediumPriorityQueueLen:

• pubsubpeer: const DefaultMaxMediumPriorityQueueLen

DefaultMaxPeersPerIp:

• types: const DefaultMaxPeersPerIp

DefaultMaxPeersPerSubnet:

• types: const DefaultMaxPeersPerSubnet

DefaultMaxProvidersPerKey:

• types: const DefaultMaxProvidersPerKey

DefaultMaxReceivedSize:

• types: const DefaultMaxReceivedSize

DefaultMaxShortlistSize:

• types: const DefaultMaxShortlistSize

DefaultMaxValueSize:

• types: const DefaultMaxValueSize

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

DefaultRecordExpirationInterval:

• types: const DefaultRecordExpirationInterval

DefaultRefreshInterval:

• natservice: const DefaultRefreshInterval

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

DefaultTopicsHigh:

• pubsub: const DefaultTopicsHigh

del:

• peerstore: proc del[T](peerBook: PeerBook[T]; peerId: PeerId): bool
• peerstore: proc del(peerStore: PeerStore; peerId: PeerId)
• provider: proc del(pk: ProvidedKeys; k: Key)
• provider: proc del(pr: ProviderRecords; index: int)
• 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,)]

Delta:

• identify: object Delta

DER:

• certificate: EncodingFormat.DER

determineQueueAction:

• pubsubpeer: proc determineQueueAction(priority: MessagePriority; sendPriorityQueueLen, mediumPriorityQueueLen, lowPriorityQueueLen: int; maxHighPriorityQueueLen, maxMediumPriorityQueueLen, maxLowPriorityQueueLen: int): QueueAction
• pubsubpeer: proc determineQueueAction(priority: MessagePriority; rpcmessagequeue: RpcMessageQueue; maxHighPriorityQueueLen, maxMediumPriorityQueueLen, maxLowPriorityQueueLen: int): QueueAction

Dial:

• dial: type Dial

dial:

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

dialAndUpgrade:

• dialer: proc dialAndUpgrade(self: Dialer; peerId: Opt[PeerId]; addrs: seq[MultiAddress]; dir = Direction.Out): InternalRaisesFuture[Muxer, (CancelledError, MaError, TransportAddressError, LPError)]
• dialer: proc 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

dialMe:

• client: method dialMe(self: AutonatClient; switch: Switch; pid: PeerId; addrs: seq[MultiAddress] = newSeq[MultiAddress]()): InternalRaisesFuture[ MultiAddress, (AutonatError, AutonatUnreachableError, CancelledError)]

dialPeerV1:

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

dialPeerV2:

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

DialRefused:

• types: ResponseStatus.DialRefused

DialRequest:

• types: object DialRequest

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]; stream: Stream; d: Discover): InternalRaisesFuture[ void, (CancelledError, LPStreamError)]
• natpmp_mapper: method discover(self: NatPmpMapper; timeout: Duration): InternalRaisesFuture[ Result[IpAddress, string], (CancelledError,)]
• portmapper: method discover(self: PortMapper; timeout: Duration): InternalRaisesFuture[ Result[IpAddress, string], (CancelledError,)]
• upnp_mapper: method discover(self: UpnpMapper; timeout: Duration): InternalRaisesFuture[ Result[IpAddress, string], (CancelledError,)]

DiscoverResponse:

• protobuf: object DiscoverResponse

dispatchFindNode:

• find: proc dispatchFindNode(kad: KadDHT; peer: PeerId; target: Key; addrs: Opt[seq[MultiAddress]] = Opt.none(seq[MultiAddress])): InternalRaisesFuture[ Result[Message, string], (CancelledError,)]

dispatchGetProviders:

• provider: proc dispatchGetProviders(kad: KadDHT; peer: PeerId; key: Key): InternalRaisesFuture[ Result[Message, string], (CancelledError,)]

dispatchGetVal:

• get: proc dispatchGetVal(kad: KadDHT; peer: PeerId; key: Key): InternalRaisesFuture[ Result[Message, string], (CancelledError,)]

DispatchProc:

• find: type DispatchProc

dispatchPutVal:

• put: proc dispatchPutVal(kad: KadDHT; peer: PeerId; key: Key; value: seq[byte]): InternalRaisesFuture[ Result[void, string], (CancelledError,)]

DNS:

• multiaddress: const DNS

DNS4:

• multiaddress: const DNS4

DNS6:

• multiaddress: const DNS6

DNSADDR:

• multiaddress: const DNSADDR

DnsAnswer:

• dnsmessage: object DnsAnswer

DNSANY:

• multiaddress: const DNSANY

DNS_OR_IP:

• multiaddress: const DNS_OR_IP

DnsRecordKind:

• dnsmessage: enum DnsRecordKind

DnsResolver:

• dnsresolver: type DnsResolver

Domain:

• api: type Domain

downloadCertificate:

• api: proc downloadCertificate(self: ACMEApi; order: Uri): InternalRaisesFuture[ ACMECertificateResponse, (ACMEError, CancelledError)]

dropFanoutPeers:

• behavior: proc dropFanoutPeers(g: GossipSub)

dropPeer:

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

DropStream:

• pubsubpeer: type DropStream

EcCurveKind:

• ecnist: enum EcCurveKind

ECDHEScheme:

• ecnist: type ECDHEScheme

ECDSA:

• crypto: PKScheme.ECDSA

EcError:

• ecnist: enum EcError

EcInsufficientTargetSize:

• ecnist: EcError.EcInsufficientTargetSize

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(c`gensym2: AutonatMsg): seq[byte]
• types: proc encode(c`gensym99: AutonatV2Msg): seq[byte]
• types: proc encode(c`gensym0: DialBack): seq[byte]
• types: proc encode(c`gensym1: DialBackResponse): seq[byte]
• core: proc encode(c`gensym0: DcutrMsg): seq[byte]
• messages: proc encode(c`gensym446: HopMessage): seq[byte]
• messages: proc encode(c`gensym0: RelayMessage): seq[byte]
• messages: proc encode(c`gensym445: StopMessage): seq[byte]
• messages: proc encode(c`gensym290: Voucher): seq[byte]
• identify: proc encode(c`gensym2: IdentifyMsg): seq[byte]
• protobuf: proc encode(msg: Message; hideConnectionStatus: bool = true): seq[byte]
• protobuf: proc encode(msg: Peer; hideConnectionStatus: bool = true): seq[byte]
• protobuf: proc encode(c`gensym2: Record): seq[byte]
• protobuf: proc encode(msg: Message; anonymize: bool): seq[byte]
• protobuf: proc encode(msg: RPCMsg; anonymize: bool): seq[byte]
• protobuf: proc encode(c`gensym0: Cookie): seq[byte]
• protobuf: proc encode(c`gensym4: Discover): seq[byte]
• protobuf: proc encode(c`gensym5: DiscoverResponse): seq[byte]
• protobuf: proc encode(c`gensym690: Message): seq[byte]
• protobuf: proc encode(c`gensym1: Register): seq[byte]
• protobuf: proc encode(c`gensym2: RegisterResponse): seq[byte]
• protobuf: proc encode(c`gensym3: Unregister): seq[byte]
• noise: proc encode(c`gensym2: NoiseHandshakePayloadMsg): seq[byte]
• routing_record: proc encode(c`gensym6: PeerRecord): seq[byte]
• signed_envelope: proc encode(envelope: Envelope): seq[byte]
• signed_envelope: proc encode[T](msg: SignedPayload[T]): seq[byte]

encodedLength:

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

encodePeerId:

• utils: proc encodePeerId(peerId: PeerId): string

encodeQuery:

• dnsmessage: proc encodeQuery(id: uint16; name: string; kind: DnsRecordKind): 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

entries:

• peerstore: proc entries(addressBook: AddressBook; peerId: PeerId): seq[AddressEntry]

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: Rng): EcResult[EcKeyPair]
• ecnist: proc ephemeral(scheme: string; rng: Rng): EcResult[EcKeyPair]

Eq:

• multiaddress: MaPatternOp.Eq

ErrBufLen:

• portmapper: const ErrBufLen

exclIfIt:

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

expandAddrs:

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

expectConnection:

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

expectDcutrConnection:

• core: proc expectDcutrConnection(connManager: ConnManager; peerId: PeerId; dir: Direction): Future[ Muxer].Raising([AlreadyExpectingConnectionError, CancelledError])

expire:

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

ExplicitIp:

• natservice: PortMappingMode.ExplicitIp

explicitIpConfig:

• natservice: proc explicitIpConfig(explicitIp: IpAddress): NATConfig

explicitIpMapped:

• natservice: proc explicitIpMapped(listenAddrs: seq[MultiAddress]; explicitIp: IpAddress): seq[ MultiAddress]

ExponentialMovingAverage:

• bandwidth: type ExponentialMovingAverage

extend:

• minasn1: proc extend[T: Asn1Buffer | Asn1Composite](abc: var T; length: int)
• peerstore: proc extend(addressBook: AddressBook; key: PeerId; addrs: seq[MultiAddress]; confidence = AddressConfidence.Medium)
• peerstore: proc extend[T](self: SeqPeerBook[T]; key: PeerId; new: seq[T])

Extension:

• extensions_types: type Extension

ExtensionsState:

• extensions: type ExtensionsState

extractPublicKey:

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

Failed:

• find: RespondedStatus.Failed

Fe:

• constants: type Fe

filterAddrs:

• peeraddrpolicy: proc filterAddrs(policy: PeerAddressPolicy; addrs: openArray[MultiAddress]): seq[ MultiAddress]

filterIt:

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

find:

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

findClosest:

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

findClosestPeerIds:

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

findClosestPeers:

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

findNode:

• find: method findNode(kad: KadDHT; target: Key): InternalRaisesFuture[seq[PeerId], (CancelledError,)]
• find: method findNode(kad: KadDHT; target: Key; rtable: RoutingTable): InternalRaisesFuture[ seq[PeerId], (CancelledError,)]
• protobuf: MessageType.findNode

findNodeDispatch:

• find: proc findNodeDispatch(kad: KadDHT; peer: PeerId; target: Key): InternalRaisesFuture[ Result[Message, string], (CancelledError,)]

findObservedIPAddr:

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

findPeer:

• find: proc findPeer(kad: KadDHT; target: 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)

fireSyncOrErr:

• portmapper: proc fireSyncOrErr(signal: ThreadSignalPtr): Result[void, string]

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)

free:

• portmapper: proc free[T](ctx: ptr T)

fromSeed:

• ed25519: proc fromSeed(t: typedesc[EdPrivateKey]; seed: openArray[byte]): EdPrivateKey

fullAddrs:

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

GeCached:

• constants: object GeCached

generate:

• rng: proc generate[V](rng: Rng; v: var openArray[V])
• rng: proc generate[T](rng: Rng; v: var T)
• rng: proc generate(rng: Rng; T: type): T:type
• rng: template generate[V](rng: Rng; v: var seq[V])

generateBytes:

• rng: proc generateBytes(rng: Rng; n: int): seq[byte]

generateX509:

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

GenericRendezVous:

• rendezvous: type GenericRendezVous

genKeyAuthorization:

• client: proc genKeyAuthorization(self: ACMEClient; token: string): KeyAuthorization

GeP1P1:

• constants: object GeP1P1

GeP2:

• constants: object GeP2

GeP3:

• constants: object GeP3

GePrecomp:

• constants: object GePrecomp

get:

• api: method get(self: ACMEApi; uri: Uri): InternalRaisesFuture[HTTPResponse, (ACMEError, HttpError, CancelledError)]
• 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]

getAddresses:

• autorelayservice: proc getAddresses(self: AutoRelayService): seq[MultiAddress]

getAds:

• protobuf: MessageType.getAds

GetAdsMessage:

• protobuf: object GetAdsMessage

getAgent:

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

getAll:

• muxer_store: proc getAll(s: MuxerStore): Table[PeerId, seq[Muxer]]

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]

getCertificate:

• client: proc getCertificate(self: ACMEClient; domain: api.Domain; certKeyPair: RsaPrivateKey; challenge: ACMEChallengeDns01Response; acmeRetries: int = 10; finalizeRetries: int = 10): InternalRaisesFuture[ ACMECertificateResponse, (ACMEError, CancelledError)]

getCertWhenReady:

• service: method getCertWhenReady(self: AutotlsService): InternalRaisesFuture[AutotlsCert, (AutoTLSError, CancelledError)]

getChallenge:

• client: proc getChallenge(self: ACMEClient; domains: seq[api.Domain]): InternalRaisesFuture[ ACMEChallengeDns01Response, (ACMEError, CancelledError)]

getConnections:

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

getError:

• portmapper: proc getError(resp: MapperResponse): string

getField:

• 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(pb: ProtoBuffer; field: int; output: var bool): 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 Opt[bool]): 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]

getHolePunchableAddrs:

• core: proc getHolePunchableAddrs(addrs: seq[MultiAddress]): seq[MultiAddress]

getHostname:

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

getIncomingSlot:

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

getInstance:

• memorymanager: proc getInstance(): memoryConnManager

getIp:

• multiaddress: proc getIp(ma: MultiAddress): Opt[IpAddress]

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]

getOrInitKid:

• client: proc getOrInitKid(self: ACMEClient): InternalRaisesFuture[Kid, (ACMEError, CancelledError)]

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]

getPeers:

• muxer_store: proc getPeers(s: MuxerStore): seq[PeerId]
• muxer_store: proc getPeers(s: MuxerStore; dir: Direction): seq[PeerId]

getPrivateKeyLength:

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

getProtocolArgument:

• multiaddress: 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, CancelledError)]

getPtr:

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

getPubKey:

• peerid: proc getPubKey(pid: PeerId): Opt[PublicKey]

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]

getResponseBody:

• utils: proc getResponseBody(response: HttpClientResponseRef): InternalRaisesFuture[JsonNode, (ACMEError, CancelledError)]

getSecret:

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

getStream:

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

GetStream:

• pubsubpeer: type GetStream

GetStreamDialError:

• pubsubpeer: object GetStreamDialError

getStreams:

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

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

gossipPartsMetadata:

• extension_partial_message: proc gossipPartsMetadata(ext: PartialMessageExtension)

GossipSub:

• types: type GossipSub

GossipSubCodec_10:

• types: const GossipSubCodec_10

GossipSubCodec_11:

• types: const GossipSubCodec_11

GossipSubCodec_12:

• types: const GossipSubCodec_12

GossipSubCodec_13:

• types: const GossipSubCodec_13

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)

GroupId:

• partial_message: type GroupId

groupId:

• partial_message: method groupId(m: PartialMessage): GroupId

guessDialableAddr:

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

handle:

• multistream: proc handle(m: MultistreamSelect; stream: Stream; active: bool = false): InternalRaisesFuture[ void, (CancelledError,)]
• multistream: proc handle(_: type MultistreamSelect; stream: Stream; 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: method handleAddProvider(kad: KadDHT; stream: Stream; msg: Message): InternalRaisesFuture[ void, (CancelledError,)]

handleBackingOff:

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

handleConn:

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

handleData:

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

handleDialDataRequest:

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

handleError:

• api: template handleError(msg: string; body: untyped): untyped

handleFindNode:

• find: method handleFindNode(kad: KadDHT; stream: Stream; msg: Message): InternalRaisesFuture[ void, (CancelledError,)]

handleGetProviders:

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

handleGetValue:

• get: method handleGetValue(kad: KadDHT; stream: Stream; msg: Message): InternalRaisesFuture[ void, (CancelledError,)]

handleGraft:

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

handleHop:

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

handleHopStreamV2:

• relay: proc handleHopStreamV2(r: Relay; stream: Stream): 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
• extension_preamble: proc handleIHave(ext: PreambleExtension; peerId: PeerId; messageId: MessageId): bool

handleIMReceiving:

• extension_preamble: proc handleIMReceiving(ext: PreambleExtension; peerId: PeerId; imreceivings: seq[IMReceiving])

handleIWant:

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

handlePing:

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

handlePreamble:

• extension_preamble: proc handlePreamble(ext: PreambleExtension; peerId: PeerId; preambles: seq[Preamble])

handlePrune:

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

handlePutValue:

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

handler:

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

handler=:

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

HandlerHolder:

• multistream: type HandlerHolder

handleRPC:

• extensions: proc handleRPC(state: ExtensionsState; peerId: PeerId; rpc: RPCMsg)

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

handleSelfPublishing:

• pubsub: template handleSelfPublishing(p: PubSub; topic: string; data: seq[byte])

handshake:

• noise: method handshake(p: Noise; conn: RawConn; initiator: bool; peerId: Opt[PeerId]): InternalRaisesFuture[ SecureConn, (CancelledError, LPStreamError)]
• secure: method handshake(s: Secure; conn: RawConn; 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
• protobuf: proc hash(peer: Peer): Hash
• pubsubpeer: proc hash(p: PubSubPeer): Hash
• timedcache: proc hash(a: TimedEntry): Hash
• connection: proc hash(p: Connection): Hash
• quictransport: proc hash(s: QuicStream): Hash

HashError:

• crypto: CryptoError.HashError

hashFor:

• types: proc hashFor(k: Key; hasher: Opt[XorDHasher]): seq[byte]

hasKey:

• provider: proc hasKey(pk: ProvidedKeys; k: Key): bool
• preamblestore: proc hasKey(ps: 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

hasResponsesFromClosestAvailable:

• find: proc hasResponsesFromClosestAvailable(state: LookupState): bool

hasSeen:

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

hasSendStream:

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

heartbeat:

• behavior: proc heartbeat(g: GossipSub): InternalRaisesFuture[void, (CancelledError,)]
• extensions: proc heartbeat(state: ExtensionsState)
• heartbeat: template heartbeat(name: string; interval: Duration; sleepFirst: bool; body: untyped): untyped
• 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:

• peerstore: AddressConfidence.High

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

HolePunchingConfig:

• natservice: object HolePunchingConfig

holePunchingConfig:

• natservice: proc holePunchingConfig(maxNumRelays: int = 1; onReservation: OnReservationHandler = nil; scheduleInterval = Opt.none(Duration)): NATConfig

HopMessage:

• messages: object HopMessage

HopMessageType:

• messages: enum HopMessageType

HPService:

• hpservice: type HPService

HTTP:

• multiaddress: const HTTP

HTTPResponse:

• api: object HTTPResponse

HTTPS:

• multiaddress: const HTTPS

identify:

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

Identify:

• identify: type Identify

identify:

• identify: proc identify(self: Identify; stream: Stream; 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

IdentifyPusher:

• identify_pusher: type IdentifyPusher

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

IMReceiving:

• messages: object IMReceiving

includeFile:

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

Infinite:

• peerstore: AddressConfidence.Infinite

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: RawConn; 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)
• find: proc init(T: type LookupState; kad: KadDHT; target: Key): T:type
• types: proc init(T: typedesc[EntryRecord]; value: Key; time: Opt[Timestamp]): EntryRecord
• ping: method init(p: Ping)
• protocol: method init(p: LPProtocol)
• 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; slowPeerPenaltyWeight = 0.0; slowPeerPenaltyThreshold = 2.0; slowPeerPenaltyDecay = 0.2; 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; maxHighPriorityQueueLen = DefaultMaxHighPriorityQueueLen; maxMediumPriorityQueueLen = DefaultMaxMediumPriorityQueueLen; maxLowPriorityQueueLen = DefaultMaxLowPriorityQueueLen; sendIDontWantOnPublish = false; testExtensionConfig = Opt.none(TestExtensionConfig); partialMessageExtensionConfig = Opt.none(PartialMessageExtensionConfig); pingpongExtensionConfig = Opt.none(PingPongExtensionConfig)): GossipSubParams
• gossipsub: method init(g: GossipSub)
• bandwidth: proc init(T: type[BandwidthTracking]; alpha: float = DefaultAlpha): T:type
• bandwidth: proc init(T: type[ExponentialMovingAverage]; alpha: float = DefaultAlpha): T:type
• preamblestore: proc init(T: typedesc[PreambleInfo]; preamble: Preamble; sender: PeerId; 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: int): 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: Rng; parameters: PubParams = false; customStreamCallbacks: Opt[CustomStreamCallbacks] = Opt.none( CustomStreamCallbacks)): P:type
• message: proc init(T: type Message; peer: Opt[PeerInfo]; data: sink seq[byte]; topic: string; seqno: Opt[uint64]; sign: bool = true): Message
• message: proc init(T: type Message; peerId: PeerId; data: sink seq[byte]; topic: string; seqno: Opt[uint64]): Message
• timedcache: proc init[K](T: type TimedCache[K]; timeout: Duration = Timeout; maxSize: int = 0; refreshOnPut: bool = true): 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: sink seq[byte]; payload: sink 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

initSignals:

• portmapper: proc initSignals[T](ctx: ptr T; owner: static string)

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(cap: int = 128): VBuffer
• vbuffer: proc initVBuffer(data: openArray[byte]; offset = 0): VBuffer
• vbuffer: proc initVBuffer(data: seq[byte]; offset = 0): VBuffer

insert:

• routing_table: proc insert(rtable: RoutingTable; nodeId: Key): bool
• routing_table: proc insert(rtable: RoutingTable; peerId: PeerId): bool
• types: proc insert(self: var LocalTable; key: Key; value: sink seq[byte]; time: Timestamp)
• preamblestore: proc insert(ps: var PreambleStore; 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

ipv4ToString:

• conversion: proc ipv4ToString(bytes: openArray[byte]): string

ipv6ToString:

• conversion: proc ipv6ToString(bytes: openArray[byte]): string

isCircuitRelayMA:

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

isConnected:

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

isControlSent:

• extensions: proc isControlSent(state: ExtensionsState; 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

isExpired:

• peerstore: proc isExpired(entry: AddressEntry; ttls: AddressConfidenceTtls): bool
• put: proc isExpired(record: EntryRecord; interval: chronos.Duration; currentUnixSeconds = nowUnixSeconds()): 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

isLoopbackMA:

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

isPrivate:

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

isPrivateMA:

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

isProtected:

• connmanager: proc isProtected(c: ConnManager; peerId: PeerId): 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(stream: Stream): bool

isRunning:

• autorelayservice: proc isRunning(self: AutoRelayService): bool

isStale:

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

isSubscribe:

• messages: template isSubscribe(s: SubOpts): bool

isSupported:

• extension_partial_message: method isSupported(ext: PartialMessageExtension; pe: PeerExtensions): bool
• extension_pingpong: method isSupported(ext: PingPongExtension; pe: PeerExtensions): bool
• extension_preamble: method isSupported(ext: PreambleExtension; pe: PeerExtensions): bool
• extensions_types: method isSupported(ext: Extension; pe: PeerExtensions): bool
• extension_test: method isSupported(ext: TestExtension; pe: PeerExtensions): 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

iterativeLookup:

• find: proc iterativeLookup(kad: KadDHT; target: Key; dispatch: DispatchProc; onReply: ReplyHandler; stopCond: StopCond): InternalRaisesFuture[ LookupState, (CancelledError,)]
• find: proc iterativeLookup(kad: KadDHT; target: Key; rtable: RoutingTable; dispatch: DispatchProc; onReply: ReplyHandler; stopCond: StopCond): InternalRaisesFuture[LookupState, (CancelledError,)]

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:

• kademlia: const KadCodec

KadDHT:

• types: type KadDHT

KadDHTConfig:

• types: object KadDHTConfig

KadDHTLimits:

• types: object KadDHTLimits

kad_message_bytes_received:

• kademlia_metrics: type kad_message_bytes_received

kad_message_bytes_sent:

• kademlia_metrics: type kad_message_bytes_sent

kad_message_duration_ms:

• kademlia_metrics: type kad_message_duration_ms

kad_messages_received:

• kademlia_metrics: type kad_messages_received

kad_messages_sent:

• kademlia_metrics: type kad_messages_sent

kad_provider_rejections_sent:

• kademlia_metrics: type kad_provider_rejections_sent

kad_provider_spillover_rounds:

• kademlia_metrics: type kad_provider_spillover_rounds

kad_responses_with_closer_peers:

• kademlia_metrics: type kad_responses_with_closer_peers

kad_routing_table_buckets:

• kademlia_metrics: type kad_routing_table_buckets

kad_routing_table_bucket_size:

• kademlia_metrics: type kad_routing_table_bucket_size

kad_routing_table_insertions:

• kademlia_metrics: type kad_routing_table_insertions

kad_routing_table_peers:

• kademlia_metrics: type kad_routing_table_peers

kad_routing_table_replacements:

• kademlia_metrics: type kad_routing_table_replacements

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

keyOrError:

• utils: proc keyOrError(table: HttpTable; key: string): string

KeyPair:

• crypto: object KeyPair

Kid:

• api: type Kid

KnownLibP2PTopics:

• pubsub: const KnownLibP2PTopics

KnownLibP2PTopicsSeq:

• pubsub: const KnownLibP2PTopicsSeq

LastSeenBook:

• peerstore: type LastSeenBook

LastSeenOutboundBook:

• peerstore: type LastSeenOutboundBook

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: PreambleStore): int
• timedcache: proc len[K](t: TimedCache[K]): 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_reachability_confidence:

• service: type libp2p_autonat_reachability_confidence

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_published_partial:

• pubsub: type libp2p_pubsub_messages_published_partial

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; stream: Stream): InternalRaisesFuture[seq[string], (CancelledError, LPStreamError, MultiStreamError)]

LocalTable:

• types: type LocalTable

lookOnce:

• find: proc lookOnce(kad: KadDHT; state: LookupState; rtable: RoutingTable; dispatch: DispatchProc; onReply: ReplyHandler): InternalRaisesFuture[ bool, (CancelledError,)]

lookupProtocol:

• multistream: proc lookupProtocol(m: MultistreamSelect; proto: string): Opt[LPProtocol]

LookupState:

• find: type LookupState

Low:

• peerstore: AddressConfidence.Low

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

makeControlExtensions:

• extensions: proc makeControlExtensions(state: ExtensionsState): ControlExtensions

makeGossipControlMessages:

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

makeKey:

• tablekey: proc makeKey(T: typedesc[TableKey]; args: varargs[string, `$`]): string

MAKind:

• multiaddress: enum MAKind

MalformedMessage:

• messages: StatusV2.MalformedMessage

manageExpiredProviders:

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

manageExpiredRecords:

• put: proc manageExpiredRecords(kad: KadDHT): InternalRaisesFuture[void, (CancelledError,)]

manageRepublishProvidedKeys:

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

map:

• natpmp_mapper: method map(self: NatPmpMapper; internalPort: Port; externalPort: Port; proto: MapProto; lease: uint32): InternalRaisesFuture[Result[Port, string], (CancelledError,)]
• portmapper: method map(self: PortMapper; internalPort: Port; externalPort: Port; proto: MapProto; lease: uint32): InternalRaisesFuture[Result[Port, string], (CancelledError,)]
• upnp_mapper: method map(self: UpnpMapper; internalPort: Port; externalPort: Port; proto: MapProto; lease: uint32): InternalRaisesFuture[Result[Port, string], (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

MapperResponse:

• portmapper: object MapperResponse

MapProto:

• portmapper: enum MapProto

MAProtocol:

• multiaddress: object MAProtocol

MaResult:

• multiaddress: type MaResult

markConnected:

• peerstore: proc markConnected(addressBook: AddressBook; peerId: PeerId; ma: MultiAddress)

Marker:

• multiaddress: MAKind.Marker

markPeerConnected:

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

markPeerDisconnected:

• peerstore: proc markPeerDisconnected(peerStore: PeerStore; 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

materializeParts:

• partial_message: method materializeParts(m: PartialMessage; metadata: PartsMetadata): Result[PartsData, string]

MaxAcceptedDialDataRequest:

• client: const MaxAcceptedDialDataRequest

MaxChannelCount:

• yamux: const MaxChannelCount

MaxCircuit:

• relay: const MaxCircuit

MaxCircuitPerPeer:

• relay: const MaxCircuitPerPeer

maxConnections:

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

MaxDialDataResponsePayload:

• client: const MaxDialDataResponsePayload

MaxHashSize:

• multihash: const MaxHashSize

MaximumDuration:

• rendezvous: const MaximumDuration

maxInlineKeyLength:

• peerid: const maxInlineKeyLength

maxInOut:

• connmanager: proc maxInOut(T: type ConnectionLimits; maxIn: int; maxOut: int): ConnectionLimits

MaxKeySize:

• rsa: const MaxKeySize

MaxMsgSize:

• coder: const MaxMsgSize
• types: const MaxMsgSize

MaxOpportunisticGraftPeers:

• types: const MaxOpportunisticGraftPeers

maxPossiblePeersOnPeerSet:

• preamblestore: const maxPossiblePeersOnPeerSet

MaxSizeError:

• lpstream: object MaxSizeError

maxTotal:

• connmanager: proc maxTotal(T: type ConnectionLimits; maxConnections: int): ConnectionLimits

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

Medium:

• peerstore: AddressConfidence.Medium

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

mergeInto:

• natservice: proc mergeInto(dst: var NATConfig; src: NATConfig)

MeshMetrics:

• types: object MeshMetrics

Message:

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

MessageId:

• messages: type MessageId

MessagePriority:

• pubsubpeer: enum MessagePriority

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

mpTcp:

• portmapper: MapProto.mpTcp

mpUdp:

• portmapper: MapProto.mpUdp

Msg:

• coder: tuple Msg

MsgIdProvider:

• pubsub: type MsgIdProvider

MsgKind:

• types: enum MsgKind

MsgType:

• types: enum MsgType
• core: 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

MuxedStream:

• connection: type MuxedStream

MuxedUpgrade:

• muxedupgrade: type MuxedUpgrade

Muxer:

• muxer: type Muxer

MuxerConstructor:

• muxer: type MuxerConstructor

MuxerError:

• muxer: object MuxerError

MuxerHandler:

• muxer: type MuxerHandler

MuxerProvider:

• muxer: object MuxerProvider

MuxerStore:

• muxer_store: type MuxerStore

NameResolver:

• nameresolver: type NameResolver

NATConfig:

• natservice: object NATConfig

NatPmp:

• natservice: PortMappingMode.NatPmp

natPmpConfig:

• natservice: proc natPmpConfig(refreshInterval = DefaultRefreshInterval; discoveryTimeout = DefaultDiscoveryTimeout; leaseDuration = DefaultLeaseDuration): NATConfig

NatPmpMapper:

• natpmp_mapper: type NatPmpMapper

NATService:

• natservice: type NATService

natService:

• natservice: proc natService(switch: Switch): Opt[NATService]

negotiateStream:

• dialer: proc negotiateStream(self: Dialer; stream: Stream; protos: seq[string]): InternalRaisesFuture[ Stream, (CancelledError, LPError)]

NetworkInterfaceProvider:

• wildcardresolverservice: type NetworkInterfaceProvider

NetworkReachability:

• types: enum NetworkReachability

new:

• api: proc new(T: typedesc[ACMEApi]; acmeServerURL: Uri = parseUri(LetsEncryptURL)): ACMEApi
• client: proc new(T: typedesc[ACMEClient]; rng: Rng; api: ACMEApi = ACMEApi.new(acmeServerURL = parseUri(LetsEncryptURL)); key: Opt[RsaPrivateKey] = Opt.none(RsaPrivateKey); kid: Kid = Kid("")): T:type
• broker: proc new(T: typedesc[AutotlsBroker]; rng: Rng; brokerURL: string = DefaultBrokerURL; peerIdAuthClient: PeerIDAuthClient = PeerIDAuthClient.new(rng)): T:type
• service: proc new(T: typedesc[AutotlsCert]; cert: TLSCertificate; privkey: TLSPrivateKey; expiry: Moment): T:type
• service: proc new(T: typedesc[AutotlsConfig]; ipAddress: Opt[IpAddress] = Opt.none(IpAddress); nameServers: seq[TransportAddress] = DefaultDnsServers; acmeServerURL: Uri = parseUri(LetsEncryptURL); renewCheckTime: Duration = DefaultRenewCheckTime; renewBufferTime: Duration = DefaultRenewBufferTime; issueRetries: int = DefaultIssueRetries; issueRetryTime: Duration = DefaultIssueRetryTime; brokerURL: string = DefaultBrokerURL; dnsServerURL: string = AutoTLSDNSServer; dnsRetries: int = 10; dnsRetryTime: Duration = 1.seconds; acmeRetries: int = 10; acmeRetryTime: Duration = 1.seconds; finalizeRetries: int = 10; finalizeRetryTime: Duration = 1.seconds): T:type
• service: proc new(T: typedesc[AutotlsService]; rng: Rng; config: AutotlsConfig = AutotlsConfig.new()): T:type
• builders: proc new(T: type[SwitchBuilder]): T:type
• connmanager: proc new(T: type ConnManager; maxConnsPerPeer: int = 0; limits: Opt[ConnectionLimits] = Opt.none(ConnectionLimits); watermark: Opt[WatermarkPolicy] = Opt.none(WatermarkPolicy); scoring: PeerScoring = PeerScoring()): ConnManager
• dialer: proc new(T: type Dialer; localPeerId: PeerId; connManager: ConnManager; peerStore: PeerStore; transports: seq[Transport]; ms: MultistreamSelect; nameResolver: NameResolver = nil): Dialer
• multistream: proc new(T: typedesc[MultistreamSelect]): T:type
• mplex: proc new(M: type Mplex; conn: RawConn; 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: RawConn; maxChannCount: int = MaxChannelCount; windowSize: int = YamuxDefaultWindowSize; maxSendQueueSize: int = MaxSendQueueSize; inTimeout: Duration = 5.minutes; outTimeout: Duration = 5.minutes): T:type
• muxer_store: proc new(T: type MuxerStore): T:type
• dnsresolver: proc new(T: typedesc[DnsResolver]; nameServers: seq[TransportAddress]; rng: Rng = newRng()): T:type
• observedaddrmanager: proc new(T: typedesc[ObservedAddrManager]; maxSize = 10; minCount = 3): T:type
• client: proc new(T: typedesc[PeerIDAuthClient]; rng: Rng): PeerIDAuthClient
• peerinfo: proc new(p: typedesc[PeerInfo]; key: PrivateKey; listenAddrs: openArray[MultiAddress] = []; protocols: openArray[string] = []; protoVersion: string = ""; agentVersion: string = ""; addressMappers = newSeq[AddressMapper](); addressPolicy: PeerAddressPolicy = defaultAddressPolicy; announcedAddrs: openArray[MultiAddress] = []): PeerInfo
• peerstore: proc new(Self: type PeerStore; identify: Identify; capacity = 1000; addressTtls = AddressConfidenceTtls()): PeerStore
• server: proc new(T: typedesc[Autonat]; switch: Switch; semSize: int = 1; dialTimeout = 15.seconds): T:type
• service: proc new(T: typedesc[AutonatService]; autonatClient: AutonatClient; rng: Rng; scheduleInterval: Opt[Duration] = Opt.none(Duration); askNewConnectedPeers = true; numPeersToAsk: int = 5; maxQueueSize: int = 10; minConfidence: float = 0.3; dialTimeout = 30.seconds; enableAddressMapper = true): T:type
• client: proc new(T: typedesc[AutonatV2Client]; rng: Rng; dialBackTimeout: Duration = DefaultDialBackTimeout): T:type
• server: proc new(Self: typedesc[AutonatV2]; switch: Switch; config: AutonatV2Config = AutonatV2Config.new()): Self: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: Rng; 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; enableDialableCandidates = false): T:type
• client: proc new(T: typedesc[DcutrClient]; connectTimeout = 15.seconds; maxDialableAddrs = 8): T:type
• server: proc new(T: typedesc[Dcutr]; switch: Switch; connectTimeout = 15.seconds; maxDialableAddrs = 8): 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]; stream: Stream; 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(Self: typedesc[RelayTransport]; cl: RelayClient; upgrader: Upgrade): Self: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(K: typedesc[KadDHT]; switch: Switch; bootstrapNodes: seq[(PeerId, seq[MultiAddress])] = @[]; config: KadDHTConfig = KadDHTConfig.new(); rng: Rng; client: bool = false; codec: string = KadCodec): K:type
• routing_table: proc new(T: typedesc[RoutingTable]; selfId: Key; config: RoutingTableConfig = RoutingTableConfig.new(); localNodeId: Opt[Key] = Opt.none(Key)): T:type
• routing_table: proc new(T: typedesc[RoutingTableConfig]; replication = DefaultReplication; hasher: Opt[XorDHasher] = NoneHasher; maxBuckets: int = DefaultMaxBuckets; selfIdPreHashed = false): T:type
• types: proc new(K: 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; recordExpirationInterval: chronos.Duration = DefaultRecordExpirationInterval; cleanupDataEntriesInterval: chronos.Duration = DefaultCleanupDataEntriesInterval; addressPolicy: PeerAddressPolicy = defaultAddressPolicy; hideConnectionStatus: bool = true; disableBootstrapping: bool = false; providerRejection: bool = false; limits: Opt[KadDHTLimits] = Opt.none(KadDHTLimits)): K:type
• types: proc new(T: typedesc[KadDHTLimits]; replication: int; quorum: int): T:type
• types: proc new(T: typedesc[ProviderManager]; providerRecordCapacity: int; providedKeyCapacity: int): T:type
• ping: proc new(T: typedesc[Ping]; handler: PingHandler = nil; rng: Rng): T:type
• protocol: proc new(T: type LPProtocol; codecs: seq[string]; handler: LPProtoHandler; maxIncomingStreamsTotal: Opt[int] | int = Opt.none(int); maxIncomingStreamsPerPeer: Opt[int] | int = Opt.none(int); maxOutgoingStreamsTotal: Opt[int] | int = Opt.none(int); maxOutgoingStreamsPerPeer: Opt[int] | int = Opt.none(int)): T:type
• extension_partial_message: proc new(T: typedesc[PartialMessageExtension]; config: PartialMessageExtensionConfig): PartialMessageExtension
• extension_pingpong: proc new(T: typedesc[PingPongExtension]; config: PingPongExtensionConfig): PingPongExtension
• extension_preamble: proc new(T: typedesc[PreambleExtension]; config: PreambleExtensionConfig; rng: Rng): PreambleExtension
• extensions: proc new(T: typedesc[ExtensionsState]; rng: Rng; updatePeerBehaviorPenalty: UpdatePeerBehaviorPenaltyProc = noopBehaviorPenaltyProc; testExtensionConfig: Opt[TestExtensionConfig] = Opt.none(TestExtensionConfig); partialMessageExtensionConfig: Opt[PartialMessageExtensionConfig] = Opt.none( PartialMessageExtensionConfig); pingpongExtensionConfig: Opt[ PingPongExtensionConfig] = Opt.none(PingPongExtensionConfig); preambleExtensionConfig: Opt[PreambleExtensionConfig] = Opt.none( PreambleExtensionConfig); externalExtensions: seq[Extension] = @[]): T:type
• extension_test: proc new(T: typedesc[TestExtension]; config: TestExtensionConfig): TestExtension
• pubsubpeer: proc new(T: typedesc[PubSubPeer]; peerId: PeerId; getStream: GetStream; onEvent: OnEvent; codec: string; maxMessageSize: int; maxHighPriorityQueueLen: int = DefaultMaxHighPriorityQueueLen; maxMediumPriorityQueueLen: int = DefaultMaxMediumPriorityQueueLen; maxLowPriorityQueueLen: int = DefaultMaxLowPriorityQueueLen; overheadRateLimitOpt: Opt[TokenBucket] = Opt.none(TokenBucket); customStreamCallbacks: Opt[CustomStreamCallbacks] = Opt.none( CustomStreamCallbacks)): T:type
• rendezvous: proc new(T: typedesc[RendezVous]; rng: Rng; config: RendezVousConfig = RendezVousConfig.new()): T:type
• rendezvous: proc new(T: typedesc[RendezVous]; switch: Switch; rng: Rng; config: RendezVousConfig = RendezVousConfig.new()): T:type
• rendezvous: proc new(T: typedesc[RendezVousConfig]; minDuration: Duration = MinimumDuration; maxDuration: Duration = MaximumDuration): T:type
• noise: proc new(T: typedesc[Noise]; rng: Rng; privateKey: PrivateKey; outgoing: bool = true; commonPrologue: seq[byte] = @[]): T:type
• secure: proc new(T: type SecureConn; conn: RawConn; peerId: PeerId; observedAddr: Opt[MultiAddress]; localAddr: Opt[MultiAddress]; timeout: Duration = DefaultConnectionTimeout): T:type
• autorelayservice: proc new(T: typedesc[AutoRelayService]; maxNumRelays: int; client: RelayClient; onReservation: OnReservationHandler; rng: Rng): T:type
• hpservice: proc new(T: typedesc[HPService]; autonatService: AutonatService; autoRelayService: AutoRelayService): T:type
• identify_pusher: proc new(T: type IdentifyPusher): T:type
• natpmp_mapper: proc new(T: typedesc[NatPmpMapper]): T:type
• upnp_mapper: proc new(T: typedesc[UpnpMapper]): T:type
• natservice: proc new(T: typedesc[NATService]; config: NATConfig; rng: Rng; portMapperFactory: PortMapperFactory = nil): 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: Rng): 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; certGenerator: CertGenerator; connManager: ConnManager = nil): QuicTransport
• quictransport: proc new(_: type QuicTransport; u: Upgrade; privateKey: PrivateKey; connManager: ConnManager = nil): 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; rng: Rng; flags: set[ServerFlags] = {}; factories: openArray[ExtFactory] = []; headersTimeout = DefaultHeadersTimeout; concurrentAccepts = DefaultConcurrentAccepts): T:type
• wstransport: proc new(T: typedesc[WsTransport]; upgrade: Upgrade; tlsPrivateKey: TLSPrivateKey; tlsCertificate: TLSCertificate; autotls: Opt[AutotlsService]; rng: Rng; tlsFlags: set[TLSFlags] = {}; flags: set[ServerFlags] = {}; factories: openArray[ExtFactory] = []; headersTimeout = DefaultHeadersTimeout; concurrentAccepts = DefaultConcurrentAccepts): 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; connManager: ConnManager): T:type
• muxedupgrade: proc new(T: type MuxedUpgrade; muxers: seq[MuxerProvider]; secureManagers: openArray[Secure] = []; ms: MultistreamSelect; connManager: Opt[ConnManager] = Opt.none(ConnManager)): T:type

newBearSslRng:

• rng: proc newBearSslRng(drbg: ref HmacDrbgContext): Rng

newFutureCompleted:

• future: template newFutureCompleted[T](): auto

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:

• rng: proc newRng(): Rng

newStream:

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

newStreamInternal:

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

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

NoiseHandshakePayloadMsg:

• noise: object NoiseHandshakePayloadMsg

NoiseNonceMaxError:

• noise: object NoiseNonceMaxError

NoiseOversizedPayloadError:

• noise: object NoiseOversizedPayloadError

Nonce:

• api: type Nonce
• types: type Nonce

None:

• multiaddress: MAKind.None

noopBehaviorPenaltyProc:

• extensions: proc noopBehaviorPenaltyProc(_: PeerId; _: float64)

noOpHasher:

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

noopReply:

• find: proc noopReply(peerId: PeerId; msgOpt: Opt[Message]; state: LookupState): InternalRaisesFuture[ void, void]

noPrivateAddressPolicy:

• peeraddrpolicy: const noPrivateAddressPolicy

NoReservation:

• messages: StatusV2.NoReservation

NotAuthorized:

• protobuf: ResponseStatus.NotAuthorized

notConnected:

• protobuf: ConnectionStatus.notConnected

notifyObservers:

• peerinfo: proc notifyObservers(p: PeerInfo)

now:

• types: proc now(T: typedesc[Timestamp]): Timestamp

nowUnixSeconds:

• types: proc nowUnixSeconds(): int64

NumBytes:

• types: type NumBytes

ObservedAddrManager:

• observedaddrmanager: type ObservedAddrManager

OffsettedSeq:

• offsettedseq: object OffsettedSeq

Ok:

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

oldestPeer:

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

OnEvent:

• pubsubpeer: type OnEvent

OngoingReceivesStore:

• types: type OngoingReceivesStore

onHandleRPC:

• extension_partial_message: method onHandleRPC(ext: PartialMessageExtension; peerId: PeerId; rpc: RPCMsg)
• extension_pingpong: method onHandleRPC(ext: PingPongExtension; peerId: PeerId; rpc: RPCMsg)
• extension_preamble: method onHandleRPC(ext: PreambleExtension; peerId: PeerId; rpc: RPCMsg)
• extensions_types: method onHandleRPC(ext: Extension; peerId: PeerId; rpc: RPCMsg)
• extension_test: method onHandleRPC(ext: TestExtension; peerId: PeerId; rpc: RPCMsg)

onHeartbeat:

• extension_partial_message: method onHeartbeat(ext: PartialMessageExtension)
• extension_pingpong: method onHeartbeat(ext: PingPongExtension)
• extension_preamble: method onHeartbeat(ext: PreambleExtension)
• extensions_types: method onHeartbeat(ext: Extension)
• extension_test: method onHeartbeat(ext: TestExtension)

Onion3:

• multiaddress: const Onion3

onNegotiated:

• extension_partial_message: method onNegotiated(ext: PartialMessageExtension; peerId: PeerId)
• extension_pingpong: method onNegotiated(ext: PingPongExtension; peerId: PeerId)
• extension_preamble: method onNegotiated(ext: PreambleExtension; peerId: PeerId)
• extensions_types: method onNegotiated(ext: Extension; peerId: PeerId)
• extension_test: method onNegotiated(ext: TestExtension; peerId: PeerId)

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)

onRemovePeer:

• extension_partial_message: method onRemovePeer(ext: PartialMessageExtension; peerId: PeerId)
• extension_pingpong: method onRemovePeer(ext: PingPongExtension; peerId: PeerId)
• extension_preamble: method onRemovePeer(ext: PreambleExtension; peerId: PeerId)
• extensions_types: method onRemovePeer(ext: Extension; peerId: PeerId)
• extension_test: method onRemovePeer(ext: TestExtension; peerId: PeerId)

OnReservationHandler:

• autorelayservice: type OnReservationHandler

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

parseAnswers:

• dnsmessage: proc parseAnswers(data: openArray[byte]; expectedId: uint16): seq[DnsAnswer]

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)]

PartialMessage:

• partial_message: type PartialMessage

PartialMessageExtension:

• extension_partial_message: type PartialMessageExtension

PartialMessageExtensionConfig:

• extension_partial_message: object PartialMessageExtensionConfig

PartialMessageExtensionRPC:

• messages: object PartialMessageExtensionRPC

PartsData:

• partial_message: type PartsData

PartsMetadata:

• partial_message: type PartsMetadata

partsMetadata:

• partial_message: method partsMetadata(m: PartialMessage): PartsMetadata

Path:

• multiaddress: MAKind.Path

payload:

• signed_envelope: proc payload(envelope: 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

PeerAddressPolicy:

• peeraddrpolicy: type PeerAddressPolicy

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]

PeerExtensions:

• extensions_types: object PeerExtensions

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

PeerInfoObserver:

• peerinfo: type PeerInfoObserver

PeerMessageDecodeError:

• pubsub: object PeerMessageDecodeError

PeerRateLimitError:

• pubsubpeer: object PeerRateLimitError

PeerRecord:

• routing_record: object PeerRecord

PeerRecordValidator:

• rendezvous: type PeerRecordValidator

peerRequestsPartial:

• extension_partial_message: proc peerRequestsPartial(ext: PartialMessageExtension; peerId: PeerId; topic: string): bool
• extensions: proc peerRequestsPartial(state: ExtensionsState; peerId: PeerId; topic: string): bool

peers:

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

peerScore:

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

PeerScoring:

• connmanager: object PeerScoring

PeerStats:

• types: object PeerStats

PeerStore:

• peerstore: type PeerStore

PeerTable:

• peertable: type PeerTable

PEM:

• certificate: EncodingFormat.PEM

PermissionDenied:

• messages: StatusV2.PermissionDenied

pick:

• rng: proc pick[T](rng: Rng; x: openArray[T]; n: int): Opt[seq[T]]

pickOne:

• rng: proc pickOne[T](rng: Rng; x: openArray[T]): Opt[T]

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; stream: Stream): InternalRaisesFuture[Duration, (CancelledError, LPStreamError, WrongPingAckError)]

PingCodec:

• ping: const PingCodec

PingError:

• ping: object PingError

PingHandler:

• ping: type PingHandler

PingPongExtension:

• extension_pingpong: type PingPongExtension

PingPongExtensionConfig:

• extension_pingpong: object PingPongExtensionConfig

PingPongExtensionRPC:

• messages: object PingPongExtensionRPC

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): Opt[PreambleInfo]

PortMapper:

• portmapper: type PortMapper

PortMapperFactory:

• natservice: type PortMapperFactory

PortMappingConfig:

• natservice: object PortMappingConfig

PortMappingMode:

• natservice: enum PortMappingMode

possiblePeersToQuery:

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

post:

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

Preamble:

• messages: object Preamble

preambleBroadcast:

• extension_preamble: proc preambleBroadcast(ext: PreambleExtension; msg: RPCMsg; peers: seq[PeerId])
• extensions: proc preambleBroadcast(state: ExtensionsState; msg: RPCMsg; peers: seq[PeerId])

preambleBroadcastIfNotReceiving:

• extension_preamble: proc preambleBroadcastIfNotReceiving(ext: PreambleExtension; msg: RPCMsg; peers: seq[PeerId])
• extensions: proc preambleBroadcastIfNotReceiving(state: ExtensionsState; msg: RPCMsg; peers: seq[PeerId])

preambleExpirationTick:

• extension_preamble: proc preambleExpirationTick(ext: PreambleExtension)

PreambleExtension:

• extension_preamble: type PreambleExtension

PreambleExtensionConfig:

• extension_preamble: object PreambleExtensionConfig

PreambleExtensionRPC:

• messages: object PreambleExtensionRPC

preambleHandleIHave:

• extensions: proc preambleHandleIHave(state: ExtensionsState; peerId: PeerId; msgId: MessageId): bool

PreambleInfo:

• preamblestore: type PreambleInfo

preambleMessageSizeThreshold:

• extension_preamble: const preambleMessageSizeThreshold

preambleMsgReceived:

• extension_preamble: proc preambleMsgReceived(ext: PreambleExtension; peerId: PeerId; msgId: MessageId; msgLen: int)
• extensions: proc preambleMsgReceived(state: ExtensionsState; peerId: PeerId; msgId: MessageId; msgLen: int)

PreamblePeerBudget:

• types: const PreamblePeerBudget

PreambleStore:

• preamblestore: object PreambleStore

PrivateKey:

• crypto: object PrivateKey

protect:

• connmanager: proc protect(c: ConnManager; peerId: PeerId; tag: string)

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 = Opt.none(Duration))

pruneExpired:

• peerstore: proc pruneExpired(addressBook: AddressBook)

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

PublicKey:

• crypto: object PublicKey

publicKey:

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

publicRoutableAddressPolicy:

• peeraddrpolicy: const publicRoutableAddressPolicy

publish:

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

PublishParams:

• pubsub: object PublishParams

publishPartial:

• gossipsub: proc publishPartial(g: GossipSub; topic: string; pm: PartialMessage; peers: seq[PeerId] = @[]): InternalRaisesFuture[void, void]
• extension_partial_message: proc publishPartial(ext: PartialMessageExtension; topic: string; pm: PartialMessage; peers: seq[PeerId] = @[]): int
• extensions: proc publishPartial(state: ExtensionsState; topic: string; pm: PartialMessage; peers: seq[PeerId] = @[]): int

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; stream: Stream): 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](cache: var TimedCache[K]; key: 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]

QueueAction:

• pubsubpeer: object QueueAction

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

QUIC_V1_IP4:

• multiaddress: const QUIC_V1_IP4

random:

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

randomKey:

• routing_table: proc randomKey(bucket: Bucket; rng: Rng): Opt[Key]

randomKeyInBucket:

• routing_table: proc randomKeyInBucket(selfId: Key; bucketIndex: int; rng: Rng; maxBuckets: int = DefaultMaxBuckets): Key

randomPeersClosestFirst:

• routing_table: proc randomPeersClosestFirst(rtable: RoutingTable; rng: Rng; count: int; maxPerBucket = high(int)): seq[Key]

randomPeersClosestFirstPeerIds:

• routing_table: proc randomPeersClosestFirstPeerIds(rtable: RoutingTable; rng: Rng; count: int; maxPerBucket = high(int)): seq[PeerId]

rateLimit:

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

RawConn:

• connection: type RawConn

ReachabilityConfig:

• natservice: object ReachabilityConfig

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)]

readFieldInto:

• crypto: proc readFieldInto(stream: InputStream; value: var PublicKey; header: FieldHeader; ProtoType: type ProtobufExt): bool
• crypto: proc readFieldInto(stream: InputStream; value: var Signature; header: FieldHeader; ProtoType: type ProtobufExt): bool
• multiaddress: proc readFieldInto(stream: InputStream; value: var MultiAddress; header: FieldHeader; ProtoType: type ProtobufExt): bool
• multiaddress: proc readFieldInto(stream: InputStream; value: var seq[MultiAddress]; header: FieldHeader; ProtoType: type ProtobufExt): bool
• peerid: proc readFieldInto(stream`gensym100: InputStream; value`gensym100: var seq[PeerId]; header`gensym100: FieldHeader; ProtoType`gensym100: type ProtobufExt): bool
• peerid: proc readFieldInto(stream: InputStream; value: var PeerId; header: FieldHeader; ProtoType: type ProtobufExt): bool
• protobuf_chronos_sec: proc readFieldInto(stream`gensym1: InputStream; value`gensym1: var seq[Duration]; header`gensym1: FieldHeader; ProtoType`gensym1: type ProtobufExt): bool
• protobuf_chronos_sec: proc readFieldInto(stream`gensym3: InputStream; value`gensym3: var seq[Moment]; header`gensym3: FieldHeader; ProtoType`gensym3: type ProtobufExt): bool
• protobuf_chronos_sec: proc readFieldInto(stream: InputStream; value: var Duration; header: FieldHeader; ProtoType: type ProtobufExt): bool
• protobuf_chronos_sec: proc readFieldInto(stream: InputStream; value: var Moment; header: FieldHeader; ProtoType: type ProtobufExt): bool

readFieldPackedInto:

• protobuf_chronos_sec: proc readFieldPackedInto(stream: InputStream; value: var seq[Duration]; header: FieldHeader; ProtoType: type ProtobufExt): bool
• protobuf_chronos_sec: proc readFieldPackedInto(stream: InputStream; value: var seq[Moment]; header: FieldHeader; ProtoType: type ProtobufExt): bool

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: RawConn): 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)

refreshTable:

• kademlia: proc refreshTable(kad: KadDHT; rtable: RoutingTable; forceRefresh = false): InternalRaisesFuture[ void, (CancelledError,)]

register:

• protobuf: MessageType.register

Register:

• protobuf: object Register

register:

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

RegisteredData:

• rendezvous: object RegisteredData

RegisterMessage:

• protobuf: object RegisterMessage

RegisterResponse:

• protobuf: object RegisterResponse

RegistrationLimitPerPeer:

• rendezvous: const RegistrationLimitPerPeer

RegistrationStatus:

• protobuf: enum RegistrationStatus

Rejected:

• protobuf: RegistrationStatus.Rejected

rejected:

• protobuf: AddProviderStatus.rejected

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

RelayReservationHandler:

• builders: type RelayReservationHandler

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)

releaseIncoming:

• protocol: proc releaseIncoming(p: LPProtocol; peerId: PeerId)

releaseOutgoing:

• protocol: proc releaseOutgoing(p: LPProtocol; peerId: PeerId)

Reliable:

• multiaddress: const Reliable

remove:

• muxer_store: proc remove(s: MuxerStore; muxer: Muxer): bool
• muxer_store: proc remove(s: MuxerStore; peerId: PeerId): seq[Muxer]

removeConnEventHandler:

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

removeDecayingTag:

• connmanager: proc removeDecayingTag(c: ConnManager; peerId: PeerId; tag: string)

removeObserver:

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

removePeer:

• extensions: proc removePeer(state: ExtensionsState; peerId: PeerId)
• 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

RendezVousConfig:

• rendezvous: object RendezVousConfig

RendezVousError:

• rendezvous: object RendezVousError

replaceIp:

• multiaddress: proc replaceIp(ma: MultiAddress; ip: IpAddress): MaResult[MultiAddress]

replenishFanout:

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

ReplyHandler:

• find: type ReplyHandler

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)]

requestAuthorizations:

• api: proc requestAuthorizations(self: ACMEApi; authorizations: seq[Authorization]; key: RsaPrivateKey; kid: Kid): InternalRaisesFuture[ ACMEAuthorizationsResponse, (ACMEError, CancelledError)]

requestChallenge:

• api: proc requestChallenge(self: ACMEApi; domains: seq[Domain]; key: RsaPrivateKey; kid: Kid): InternalRaisesFuture[ACMEChallengeDns01Response, (ACMEError, CancelledError)]

requestCheck:

• api: proc requestCheck(self: ACMEApi; checkURL: Uri; checkKind: ACMECheckKind; key: RsaPrivateKey; kid: Kid): InternalRaisesFuture[ ACMECheckResponse, (ACMEError, CancelledError)]

requestFinalize:

• api: proc requestFinalize(self: ACMEApi; domain: Domain; finalize: Uri; certKeyPair: RsaPrivateKey; key: RsaPrivateKey; kid: Kid): InternalRaisesFuture[ ACMEFinalizeResponse, (ACMEError, CancelledError)]

requestGetOrder:

• api: proc requestGetOrder(self: ACMEApi; order: Uri): InternalRaisesFuture[ ACMEOrderResponse, (ACMEError, CancelledError)]

requestLocally:

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

requestNewOrder:

• api: proc requestNewOrder(self: ACMEApi; domains: seq[Domain]; key: RsaPrivateKey; kid: Kid): InternalRaisesFuture[ACMEChallengeResponse, (ACMEError, CancelledError)]

requestNonce:

• api: method requestNonce(self: ACMEApi): InternalRaisesFuture[Nonce, (ACMEError, CancelledError)]

requestRegister:

• api: proc requestRegister(self: ACMEApi; key: RsaPrivateKey): InternalRaisesFuture[ ACMERegisterResponse, (ACMEError, CancelledError)]

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)]

reserveIncoming:

• protocol: proc reserveIncoming(p: LPProtocol; peerId: PeerId): bool

reserveOutgoing:

• protocol: proc reserveOutgoing(p: LPProtocol; peerId: PeerId): bool

reset:

• lpstream: template reset[T: LPStream](s: T): untyped

resetChannel:

• lpchannel: proc resetChannel(s: LPChannel; isLocal: bool): InternalRaisesFuture[void, void]

resetImpl:

• lpchannel: method resetImpl(s: LPChannel): InternalRaisesFuture[void, void]
• yamux: method resetImpl(channel: YamuxChannel): InternalRaisesFuture[void, void]
• rconn: method resetImpl(self: RelayConnection): InternalRaisesFuture[void, void]
• secure: method resetImpl(s: SecureConn): InternalRaisesFuture[void, void]
• lpstream: method resetImpl(s: LPStream): InternalRaisesFuture[void, void]
• quictransport: method resetImpl(stream: QuicStream): InternalRaisesFuture[void, void]

resolveDnsAddr:

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

resolveIp:

• dnsresolver: method resolveIp(self: DnsResolver; address: string; port: Port; domain: Domain = Domain.AF_UNSPEC): InternalRaisesFuture[ seq[TransportAddress], (CancelledError, TransportAddressError)]
• 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:

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

ResourceLimitExceeded:

• messages: StatusV2.ResourceLimitExceeded

RespondedStatus:

• find: enum RespondedStatus

ResponseStatus:

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

rewardDelivered:

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

Rng:

• rng: type Rng

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

RsaKeyTooLargeError:

• rsa: RsaError.RsaKeyTooLargeError

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

runHandleLoop:

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

safeClose:

• transport: template safeClose(stream: untyped)

safeCloseWait:

• transport: template safeCloseWait(stream: untyped)

safeConvert:

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

safeRelease:

• portmapper: proc safeRelease(lock: AsyncLock; owner: static string)

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: RawConn; peerId: Opt[PeerId]): InternalRaisesFuture[ SecureConn, (CancelledError, LPStreamError)]
• wstransport: proc secure(self: WsTransport): bool
• upgrade: proc secure(self: Upgrade; conn: RawConn; peerId: Opt[PeerId]): InternalRaisesFuture[ SecureConn, (CancelledError, LPError)]

SecureConn:

• secure: type SecureConn

SecureConnTrackerName:

• secure: const SecureConnTrackerName

SecureProtocol:

• builders: enum SecureProtocol

select:

• multistream: proc select(_: MultistreamSelect | type MultistreamSelect; stream: Stream; proto: seq[string]): InternalRaisesFuture[string, (CancelledError, LPStreamError, MultiStreamError)]
• multistream: proc select(_: MultistreamSelect | type MultistreamSelect; stream: Stream; proto: string): InternalRaisesFuture[bool, (CancelledError, LPStreamError, MultiStreamError)]
• multistream: proc select(m: MultistreamSelect; stream: Stream): 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]

selectBest:

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

selectCloserPeers:

• find: proc selectCloserPeers(state: LookupState; amount: int; excludeResponded: bool = true): seq[ PeerId]

selectMuxer:

• connmanager: proc selectMuxer(c: ConnManager; peerId: PeerId): Muxer
• connmanager: proc selectMuxer(c: ConnManager; peerId: PeerId; dir: Direction): Muxer
• muxer_store: proc selectMuxer(s: MuxerStore; 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)]
• core: proc send(stream: Stream; msgType: MsgType; addrs: seq[MultiAddress]): InternalRaisesFuture[ void, (CancelledError, LPStreamError)]
• pubsub: proc send(p: PubSub; peer: PubSubPeer; msg: RPCMsg; priority: MessagePriority; useCustomStream: bool = false)
• pubsubpeer: proc send(p: PubSubPeer; msg: RPCMsg; anonymize: bool; priority: MessagePriority; useCustomStream: bool = false)

sendChallenge:

• broker: proc sendChallenge(self: AutotlsBroker; peerInfo: PeerInfo; addrs: seq[MultiAddress]; keyAuth: KeyAuthorization): InternalRaisesFuture[void, (AutoTLSError, PeerIDAuthError, CancelledError)]

sendChallengeCompleted:

• api: proc sendChallengeCompleted(self: ACMEApi; chalURL: Uri; key: RsaPrivateKey; kid: Kid): InternalRaisesFuture[ ACMECompletedResponse, (ACMEError, CancelledError)]

sendDialRequest:

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

sendDiscoverResponse:

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

sendDiscoverResponseError:

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

sendEncoded:

• pubsubpeer: proc sendEncoded(p: PubSubPeer; msg: sink seq[byte]; priority: MessagePriority; useCustomStream: bool = false): Future[void]

sendHopStatus:

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

sendRegisterResponse:

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

sendRegisterResponseError:

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

sendStatus:

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

sendStopStatus:

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

sendSubs:

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

SeqPeerBook:

• peerstore: type SeqPeerBook

serializerFor:

• protobuf: macro serializerFor(_: type Protobuf; Types: untyped; withMetrics: bool = false; domain: string = ""): untyped

Service:

• switch: type Service

ServiceSetupError:

• switch: object ServiceSetupError

set:

• peerstore: proc set(addressBook: AddressBook; peerId: PeerId; addrs: seq[MultiAddress]; confidence = AddressConfidence.Medium)

setError:

• portmapper: proc setError(resp: var MapperResponse; msg: string)

setMaxRecvWindow:

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

setStatusAndConfidenceHandler:

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

setup:

• service: method setup(self: AutotlsService; switch: Switch)
• service: method setup(self: AutonatService; switch: Switch)
• client: proc setup(self: AutonatV2Client; switch: Switch)
• service: method setup(self: AutonatV2Service; switch: Switch)
• relay: proc setup(r: Relay; switch: Switch)
• rendezvous: proc setup[E](rdv: GenericRendezVous[E]; switch: Switch)
• autorelayservice: method setup(self: AutoRelayService; switch: Switch)
• hpservice: method setup(self: HPService; switch: Switch)
• identify_pusher: method setup(p: IdentifyPusher; switch: Switch)
• natservice: method setup(self: NATService; switch: Switch)
• wildcardresolverservice: method setup(self: WildcardAddressResolverService; switch: Switch)
• switch: method setup(self: Service; switch: Switch)

setupMappings:

• natservice: proc setupMappings(self: NATService; listenAddrs: seq[MultiAddress]): InternalRaisesFuture[ seq[MultiAddress], (CancelledError,)]

Sha256:

• crypto: DigestSheme.Sha256

Sha512:

• crypto: DigestSheme.Sha512

shift:

• mcache: proc shift(c: var MCache)

shortLog:

• crypto: proc shortLog(key: PrivateKey | PublicKey): string
• multiaddress: proc shortLog(addrs: seq[MultiAddress]; maxAddrs: int): 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: ControlIWant): auto
• messages: proc shortLog(c: ControlMessage): auto
• messages: proc shortLog(s: ControlPrune): auto
• messages: proc shortLog(s: IMReceiving): auto
• messages: proc shortLog(msg: Message): auto
• messages: proc shortLog(so: Opt[ControlExtensions]): auto
• messages: proc shortLog(pme: PartialMessageExtensionRPC): auto
• messages: proc shortLog(rpc: PingPongExtensionRPC): auto
• messages: proc shortLog(s: Preamble): auto
• messages: proc shortLog(rpc: PreambleExtensionRPC): 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
• shortlog: proc shortLog(item: openArray[byte]): string
• shortlog: proc shortLog(item: string): string

shuffle:

• rng: proc shuffle[T](rng: Rng; 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
• protobuf: proc sign(ticket: var Ticket; privateKey: PrivateKey): Result[void, CryptoError]
• 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

SomeUVarint:

• varint: type SomeUVarint

SomeVarint:

• varint: type SomeVarint

SPRBook:

• peerstore: type SPRBook

SqrTm1:

• constants: const SqrTm1

start:

• service: method start(self: AutotlsService; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• multistream: proc start(m: MultistreamSelect): InternalRaisesFuture[void, (CancelledError,)]
• service: method start(self: AutonatService; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• service: method start(self: AutonatV2Service; switch: Switch): 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,)]
• autorelayservice: method start(self: AutoRelayService; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• hpservice: method start(self: HPService; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• identify_pusher: method start(p: IdentifyPusher; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• natservice: method start(self: NATService; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• wildcardresolverservice: method start(self: WildcardAddressResolverService; switch: Switch): InternalRaisesFuture[ void, (CancelledError,)]
• switch: proc start(s: Switch): InternalRaisesFuture[void, (CancelledError, LPError)]
• switch: method start(self: Service; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• 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)]

startAddressPruning:

• peerstore: proc startAddressPruning(peerStore: PeerStore)

StartGroup:

• minprotobuf: ProtoFieldKind.StartGroup

startProviding:

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

startSync:

• client: proc startSync(self: DcutrClient; switch: Switch; remotePeerId: PeerId; addrs: seq[MultiAddress]): InternalRaisesFuture[void, (DcutrError, CancelledError)]

StatusAndConfidenceHandler:

• service: type StatusAndConfidenceHandler

statusAndConfidenceHandler:

• service: proc statusAndConfidenceHandler(self: AutonatService; statusAndConfidenceHandler: StatusAndConfidenceHandler)

StatusAndConfidenceHandler:

• service: type StatusAndConfidenceHandler

StatusV1:

• messages: enum StatusV1

StatusV2:

• messages: enum StatusV2

stop:

• service: method stop(self: AutotlsService; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• multistream: proc stop(m: MultistreamSelect): InternalRaisesFuture[void, void]
• service: method stop(self: AutonatService; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• service: method stop(self: AutonatV2Service; switch: Switch): InternalRaisesFuture[void, (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]
• autorelayservice: method stop(self: AutoRelayService; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• hpservice: method stop(self: HPService; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• identify_pusher: method stop(p: IdentifyPusher; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• natservice: method stop(self: NATService; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• wildcardresolverservice: method stop(self: WildcardAddressResolverService; switch: Switch): InternalRaisesFuture[ void, (CancelledError,)]
• switch: proc stop(s: Switch): InternalRaisesFuture[void, (CancelledError,)]
• switch: method stop(self: Service; switch: Switch): InternalRaisesFuture[void, (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]

StopCond:

• find: type StopCond

StopMessage:

• messages: object StopMessage

StopMessageType:

• messages: enum StopMessageType

stopProviding:

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

stopTasks:

• pubsubpeer: proc stopTasks(p: PubSubPeer)

storeMuxer:

• connmanager: proc storeMuxer(c: ConnManager; muxer: Muxer): InternalRaisesFuture[void, (CancelledError, LPError)]

Stream:

• connection: type Stream

StreamHandler:

• muxer: type StreamHandler

StreamTracker:

• lpstream: type StreamTracker

stretchKeys:

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

stripPeerId:

• peerinfo: proc stripPeerId(ma: MultiAddress): MultiAddress

SubOpts:

• messages: object SubOpts

subscribe:

• pubsub: proc subscribe(p: PubSub; topic: string; handler: TopicHandler; requestsPartial: bool = false; supportsSendingPartial: bool = false)

subscribePeer:

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

SubscriptionValidator:

• pubsub: type SubscriptionValidator

Success:

• find: RespondedStatus.Success

supported:

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

SupportedSchemes:

• crypto: const SupportedSchemes

SupportedSchemesInt:

• crypto: const SupportedSchemesInt

SupportedWireTypes:

• minprotobuf: const SupportedWireTypes

supportsPacked:

• crypto: proc supportsPacked(_: type seq[PublicKey]; ProtoType`gensym339: type ProtobufExt): bool
• crypto: proc supportsPacked(_: type seq[Signature]; ProtoType`gensym341: type ProtobufExt): bool
• crypto: proc supportsPacked(_: type PublicKey; ProtoType`gensym339: type ProtobufExt): bool
• crypto: proc supportsPacked(_: type Signature; ProtoType`gensym341: type ProtobufExt): bool
• multiaddress: proc supportsPacked(_: type seq[MultiAddress]; ProtoType`gensym544: type ProtobufExt): bool
• multiaddress: proc supportsPacked(_: type MultiAddress; ProtoType`gensym544: type ProtobufExt): bool
• peerid: proc supportsPacked(_: type seq[PeerId]; ProtoType`gensym100: type ProtobufExt): bool
• peerid: proc supportsPacked(_: type PeerId; ProtoType`gensym100: type ProtobufExt): bool
• protobuf_chronos_sec: proc supportsPacked(_: type seq[Duration]; ProtoType`gensym1: type ProtobufExt): bool
• protobuf_chronos_sec: proc supportsPacked(_: type seq[Moment]; ProtoType`gensym3: type ProtobufExt): bool
• protobuf_chronos_sec: proc supportsPacked(_: type Duration; ProtoType`gensym1: type ProtobufExt): bool
• protobuf_chronos_sec: proc supportsPacked(_: type Moment; ProtoType`gensym3: type ProtobufExt): bool

Switch:

• switch: type Switch

SwitchBuilder:

• builders: type SwitchBuilder

TableKey:

• tablekey: object TableKey

tagPeer:

• connmanager: proc tagPeer(c: ConnManager; peerId: PeerId; tag: string; value: int)

tagPeerDecaying:

• connmanager: proc tagPeerDecaying(c: ConnManager; peerId: PeerId; tag: string; value: int; interval: Duration; decayFn: DecayFn)

take:

• collections: proc take[T](s: seq[T]; n: int): seq[T]

TCP:

• multiaddress: const TCP

TCP_DNS:

• multiaddress: const TCP_DNS

TCP_IP:

• multiaddress: const TCP_IP

TCP_IP4:

• multiaddress: const TCP_IP4

TCP_IP6:

• multiaddress: const TCP_IP6

TcpOnion3:

• multiaddress: const TcpOnion3

tcpProtocol:

• multiaddress: IpTransportProtocol.tcpProtocol

TcpTransport:

• tcptransport: type TcpTransport

TcpTransportError:

• tcptransport: object TcpTransportError

TcpTransportTrackerName:

• tcptransport: const TcpTransportTrackerName

TestExtension:

• extension_test: type TestExtension

TestExtensionConfig:

• extension_test: object TestExtensionConfig

TestExtensionRPC:

• messages: object TestExtensionRPC

thumbprint:

• utils: proc thumbprint(key: RsaPrivateKey): string

Ticket:

• protobuf: object Ticket

TimedCache:

• timedcache: object TimedCache

TimedEntry:

• timedcache: type TimedEntry

Timeout:

• timedcache: const Timeout

TimeoutHandler:

• connection: type TimeoutHandler

Timestamp:

• types: type Timestamp

TimestampFormat:

• types: const TimestampFormat

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; target: var openArray[byte]): EcResult[int]
• ecnist: proc toBytes(pubkey: EcPublicKey; target: 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
• protobuf: proc toBytes(ticket: Ticket): seq[byte]
• varint: template toBytes(vtype: typedesc[PB]; value: PBSomeVarint): auto

toChunks:

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

toCid:

• peerid: proc toCid(pid: PeerId): Result[Cid, cstring]
• types: proc toCid(k: Key): Cid

toCidString:

• peerid: proc toCidString(pid: PeerId; encoding = "base32"): Result[string, cstring]

toException:

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

toFlattenedJws:

• jws: proc toFlattenedJws(protectedHeader: JsonNode; payload: JsonNode; key: rsa.RsaPrivateKey): JsonNode

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:

• opt: proc toOpt[T](v: Opt[T] | T): Opt[T]
• opt: proc toOpt[T: ref object](x: T): Opt[T]
• opt: 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(entries: seq[NodeEntry]): seq[PeerId]
• types: proc toPeerIds(peers: seq[Peer]): seq[PeerId]

toPeers:

• types: proc toPeers(switch: Switch; keys: seq[Key]): seq[Peer]

TopicData:

• pubsub: type TopicData

TopicHandler:

• pubsub: type TopicHandler

TopicInfo:

• types: object TopicInfo

topicLabel:

• pubsub: proc topicLabel(p: PubSub; topic: string | Opt[string]): string

TopicOpts:

• extension_partial_message: object TopicOpts

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]

toTransportAddress:

• transport: proc toTransportAddress(self: Transport; addrsMa: seq[MultiAddress]): Result[ seq[TransportAddress], string]

toUnixSeconds:

• types: proc toUnixSeconds(time: Timestamp): Result[int64, ref CatchableError]

trackConnection:

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

trackDecodeBytes:

• protobuf: template trackDecodeBytes(count: int; msgType: typedesc; domain: string)

trackEncodeBytes:

• protobuf: template trackEncodeBytes(count: int; msgType: typedesc; domain: string)

trackFut:

• future: proc trackFut[T](futs: var seq[T]; fut: T)

trackMuxer:

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

trackSend:

• pubsubpeer: proc trackSend(p: PubSubPeer; fut: Future[void])

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

TransportStartError:

• transport: object TransportStartError

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:

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

TXT:

• dnsmessage: DnsRecordKind.TXT

UDP:

• multiaddress: const UDP

UDP_DNS:

• multiaddress: const UDP_DNS

UDP_IP:

• multiaddress: const UDP_IP

UDP_IP4:

• multiaddress: const UDP_IP4

udpProtocol:

• multiaddress: IpTransportProtocol.udpProtocol

Unavailable:

• protobuf: ResponseStatus.Unavailable

UnexpectedMessage:

• messages: StatusV2.UnexpectedMessage

UNIX:

• multiaddress: const UNIX

unmap:

• natpmp_mapper: method unmap(self: NatPmpMapper; externalPort: Port; proto: MapProto): InternalRaisesFuture[ Result[void, string], (CancelledError,)]
• portmapper: method unmap(self: PortMapper; externalPort: Port; proto: MapProto): InternalRaisesFuture[ Result[void, string], (CancelledError,)]
• upnp_mapper: method unmap(self: UpnpMapper; externalPort: Port; proto: MapProto): InternalRaisesFuture[ Result[void, string], (CancelledError,)]

unprotect:

• connmanager: proc unprotect(c: ConnManager; peerId: PeerId; tag: string): bool

Unregister:

• protobuf: object Unregister

unregister:

• rendezvous: proc unregister[E](rdv: GenericRendezVous[E]; stream: Stream; 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)

untagPeer:

• connmanager: proc untagPeer(c: ConnManager; peerId: PeerId; tag: string)

Unused:

• messages: StatusV2.Unused

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)

UpdatePeerBehaviorPenaltyProc:

• extensions_types: type UpdatePeerBehaviorPenaltyProc

updatePeerInfo:

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

updatePeers:

• find: proc updatePeers(kad: KadDHT; peers: seq[(PeerId, seq[MultiAddress])])
• find: proc updatePeers(kad: KadDHT; peerInfos: seq[PeerInfo])
• find: proc updatePeers(switch: Switch; addressPolicy: PeerAddressPolicy; rtable: RoutingTable; peerInfos: seq[PeerInfo]; maxPeersPerIp: int = DefaultMaxPeersPerIp; maxPeersPerIpv4Subnet: int = DefaultMaxPeersPerSubnet; maxPeersPerIpv6Subnet: int = DefaultMaxPeersPerSubnet)

updateRoutingTableMetrics:

• routing_table: proc updateRoutingTableMetrics(rtable: RoutingTable)

updateScores:

• scoring: proc updateScores(g: GossipSub)

updateShortlist:

• find: proc updateShortlist(state: LookupState; msg: Message): seq[PeerInfo]

upgrade:

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

Upgrade:

• upgrade: type Upgrade

upgrade:

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

UpgradeError:

• switch: object UpgradeError

UpgradeFailedError:

• upgrade: object UpgradeFailedError

UpgradeTimeout:

• switch: const UpgradeTimeout

Upnp:

• natservice: PortMappingMode.Upnp

upnpConfig:

• natservice: proc upnpConfig(refreshInterval = DefaultRefreshInterval; discoveryTimeout = DefaultDiscoveryTimeout; leaseDuration = DefaultLeaseDuration): NATConfig

UpnpMapper:

• upnp_mapper: type UpnpMapper

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,)]
• messages: proc validate(msg: RPCMsg): Result[void, string]
• messages: proc validate(sub: SubOpts): Result[void, string]

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

Varint:

• minprotobuf: ProtoFieldKind.Varint

VarintError:

• varint: enum VarintError

VarintResult:

• varint: type VarintResult

VBuffer:

• vbuffer: object VBuffer

verifiedIdentityKey:

• certificate: proc verifiedIdentityKey(self: P2pCertificate): Opt[PublicKey]

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
• protobuf: proc verify(ticket: Ticket; publicKey: PublicKey): bool
• message: proc verify(m: Message): bool
• signed_envelope: proc verify(envelope: Envelope; domain: string): bool
• certificate: proc verify(self: P2pCertificate; expectedPeerId: PeerId): 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

Wait:

• protobuf: RegistrationStatus.Wait

waitExpectedConnection:

• core: proc waitExpectedConnection[T](fut: Future[T]): Future[void].Raising( [DialFailedError, CancelledError])

waitForPeerReady:

• connmanager: proc waitForPeerReady(c: ConnManager; peerId: PeerId; timeout = 5.seconds): InternalRaisesFuture[ bool, (CancelledError,)]

waitForTCPServer:

• future: proc waitForTCPServer(taddr: TransportAddress; retries: int = 20; delay: chronos.Duration = 500.milliseconds): Future[bool]

wasResetLocally:

• lpstream: proc wasResetLocally(s: LPStream): bool

WatermarkPolicy:

• connmanager: object WatermarkPolicy

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): SwitchBuilder
• builders: proc withAddress(b: SwitchBuilder; address: MultiAddress; enableWildcardResolver: bool): SwitchBuilder

withAddressConfidenceTtls:

• builders: proc withAddressConfidenceTtls(b: SwitchBuilder; ttls: AddressConfidenceTtls): SwitchBuilder

withAddresses:

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

withAddressPolicy:

• builders: proc withAddressPolicy(b: SwitchBuilder; addressPolicy: PeerAddressPolicy): SwitchBuilder

withAgentVersion:

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

withAnnouncedAddress:

• builders: proc withAnnouncedAddress(b: SwitchBuilder; address: MultiAddress): SwitchBuilder

withAnnouncedAddresses:

• builders: proc withAnnouncedAddresses(b: SwitchBuilder; addresses: seq[MultiAddress]): SwitchBuilder

withAutonat:

• builders: proc withAutonat(b: SwitchBuilder; enabled: bool = true): SwitchBuilder

withAutonatV2:

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

withAutonatV2Server:

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

withAutotls:

• builders: proc withAutotls(b: SwitchBuilder; config: AutotlsConfig = AutotlsConfig.new()): SwitchBuilder

withCircuitRelay:

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

withConnectionLimits:

• builders: proc withConnectionLimits(b: SwitchBuilder; limits: ConnectionLimits): SwitchBuilder

withControl:

• messages: proc withControl(_: typedesc[RPCMsg]; control: sink ControlMessage): RPCMsg

withExtensions:

• messages: proc withExtensions(_: typedesc[ControlMessage]; ext: sink ControlExtensions): ControlMessage

withGraft:

• messages: proc withGraft(_: typedesc[ControlMessage]; topicID: string): ControlMessage

withHolePunching:

• builders: proc withHolePunching(b: SwitchBuilder; maxNumRelays: int; onReservationHandler: RelayReservationHandler): SwitchBuilder

withIdentifyPusher:

• builders: proc withIdentifyPusher(b: SwitchBuilder; enabled: bool = true): SwitchBuilder

withIDontWant:

• messages: proc withIDontWant(_: typedesc[ControlMessage]; msgId: MessageId): ControlMessage
• messages: proc withIDontWant(_: typedesc[ControlMessage]; msgIds: sink seq[MessageId]): ControlMessage

withIHave:

• messages: proc withIHave(_: typedesc[ControlMessage]; topicID: string; messageIDs: sink seq[MessageId]): ControlMessage

withIMReceiving:

• messages: proc withIMReceiving(_: typedesc[RPCMsg]; preamble: sink Preamble): RPCMsg
• messages: proc withIMReceiving(_: typedesc[RPCMsg]; imreceiving: sink seq[IMReceiving]): RPCMsg

withIWant:

• messages: proc withIWant(_: typedesc[ControlMessage]; msgId: MessageId): ControlMessage
• messages: proc withIWant(_: typedesc[ControlMessage]; msgIds: sink seq[MessageId]): ControlMessage

withKademlia:

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

withLock:

• lock: template withLock(a: AsyncLock; body: untyped)

withMaxConnections:

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

withMaxConnsPerPeer:

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

withMaxInOut:

• builders: proc withMaxInOut(b: SwitchBuilder; maxIn: int; maxOut: int): SwitchBuilder

withMemoryTransport:

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

withMessages:

• messages: proc withMessages(_: typedesc[RPCMsg]; msg: sink Message): RPCMsg
• messages: proc withMessages(_: typedesc[RPCMsg]; messages: sink seq[Message]): RPCMsg

withMplex:

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

withNameResolver:

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

withNAT:

• builders: proc withNAT(b: SwitchBuilder; config: NATConfig; portMapperFactory: PortMapperFactory = nil): SwitchBuilder

withNoise:

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

withObservedAddrManager:

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

withPeerScoring:

• builders: proc withPeerScoring(b: SwitchBuilder; scoring: PeerScoring = PeerScoring()): 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

withPing:

• messages: proc withPing(_: typedesc[RPCMsg]; ping: sink Opt[seq[byte]]): RPCMsg
• messages: proc withPing(_: typedesc[RPCMsg]; ping: sink seq[byte]): RPCMsg

withPong:

• messages: proc withPong(_: typedesc[RPCMsg]; pong: sink seq[byte]): RPCMsg

withPreamble:

• messages: proc withPreamble(_: typedesc[RPCMsg]; msgs: seq[Message]; msgIds: seq[MessageId]): RPCMsg
• messages: proc withPreamble(_: typedesc[RPCMsg]; preamble: sink seq[Preamble]): RPCMsg
• messages: proc withPreamble(_: typedesc[RPCMsg]; topic: string; msgId: MessageId; messageLength: int): RPCMsg

withPrivateAddressFilter:

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

withPrivateKey:

• builders: proc withPrivateKey(b: SwitchBuilder; privateKey: PrivateKey | Opt[PrivateKey]): SwitchBuilder

withProtoVersion:

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

withPrune:

• messages: proc withPrune(_: typedesc[ControlMessage]; topicID: string; backoff: uint64; peers: sink seq[PeerInfoMsg]): ControlMessage

withQuicTransport:

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

withRendezVous:

• builders: proc withRendezVous(b: SwitchBuilder; config: RendezVousConfig = RendezVousConfig.new()): SwitchBuilder

withRng:

• builders: proc withRng(b: SwitchBuilder; rng: Rng): SwitchBuilder

withRpcSlot:

• types: template withRpcSlot(kad: KadDHT)

withSignedPeerRecord:

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

withSubscriptions:

• messages: proc withSubscriptions(_: typedesc[RPCMsg]; subscriptions: sink seq[SubOpts]): RPCMsg

withTcpTransport:

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

withTransport:

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

WithUint32BeLength:

• minprotobuf: ProtoFlags.WithUint32BeLength

WithUint32LeLength:

• minprotobuf: ProtoFlags.WithUint32LeLength

withValue:

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

WithVarintLength:

• minprotobuf: ProtoFlags.WithVarintLength

withWatermarkPolicy:

• builders: proc withWatermarkPolicy(b: SwitchBuilder; lowWater: int; highWater: int; gracePeriod: Duration = 0.minutes; silencePeriod: Duration = 10.seconds): SwitchBuilder

withWildcardResolver:

• builders: proc withWildcardResolver(b: SwitchBuilder; enabled: bool = true): SwitchBuilder

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(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: sink seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• yamux: method write(channel: YamuxChannel; msg: sink 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(pb: var ProtoBuffer; field: int; value: bool)
• minprotobuf: proc write[T: byte | char](pb: var ProtoBuffer; field: int; value: openArray[T])
• minprotobuf: proc write(pb: var ProtoBuffer; field: int; value: Opt[bool])
• 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: sink seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• noise: method write(sconn: NoiseConnection; message: sink seq[byte]): InternalRaisesFuture[ void, (CancelledError, LPStreamError)]
• bridgestream: method write(s: BridgeStream; msg: sink seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• chronosstream: method write(s: ChronosStream; msg: sink seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• lpstream: proc write(s: LPStream; msg: string): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• lpstream: method write(s: LPStream; msg: sink seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• quictransport: method write(stream: QuicStream; bytes: sink seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• wstransport: method write(s: WsStream; msg: sink seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]

writeArray:

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

writeField:

• crypto: proc writeField(stream: OutputStream; field: int; value: PublicKey; ProtoType: type ProtobufExt; skipDefault: static bool = false)
• crypto: proc writeField(stream: OutputStream; field: int; value: Signature; ProtoType: type ProtobufExt; skipDefault: static bool = false)
• multiaddress: proc writeField(stream`gensym544: OutputStream; field`gensym544: int; value`gensym544: seq[MultiAddress]; ProtoType`gensym544: type ProtobufExt; skipDefault`gensym544: static bool = false)
• multiaddress: proc writeField(stream: OutputStream; field: int; value: MultiAddress; ProtoType: type ProtobufExt; skipDefault: static bool = false)
• peerid: proc writeField(stream`gensym100: OutputStream; field`gensym100: int; value`gensym100: seq[PeerId]; ProtoType`gensym100: type ProtobufExt; skipDefault`gensym100: static bool = false)
• peerid: proc writeField(stream: OutputStream; field: int; value: PeerId; ProtoType: type ProtobufExt; skipDefault: static bool = false)
• protobuf_chronos_sec: proc writeField(stream`gensym1: OutputStream; field`gensym1: int; value`gensym1: seq[Duration]; ProtoType`gensym1: type ProtobufExt; skipDefault`gensym1: static bool = false)
• protobuf_chronos_sec: proc writeField(stream`gensym3: OutputStream; field`gensym3: int; value`gensym3: seq[Moment]; ProtoType`gensym3: type ProtobufExt; skipDefault`gensym3: static bool = false)
• protobuf_chronos_sec: proc writeField(stream: OutputStream; field: int; value: Duration; ProtoType: type ProtobufExt; skipDefault: static bool = false)
• protobuf_chronos_sec: proc writeField(stream: OutputStream; field: int; value: Moment; ProtoType: type ProtobufExt; skipDefault: static bool = false)

writeFieldPacked:

• protobuf_chronos_sec: proc writeFieldPacked(stream: OutputStream; field: int; value: seq[Duration]; ProtoType: type ProtobufExt)
• protobuf_chronos_sec: proc writeFieldPacked(stream: OutputStream; field: int; value: seq[Moment]; ProtoType: type ProtobufExt)

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: RawConn; id: uint64; msgType: MessageType; data: seq[byte] = @[]): InternalRaisesFuture[ void, (CancelledError, LPStreamError)]
• coder: proc writeMsg(conn: RawConn; id: uint64; msgType: MessageType; data: string): InternalRaisesFuture[ void, (CancelledError, LPStreamError)]

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): 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