Index

Modules: libp2p, libp2p/builders, libp2p/connmanager, libp2p/crypto/chacha20poly1305, libp2p/crypto/crypto, libp2p/crypto/curve25519, libp2p/crypto/ecnist, libp2p/crypto/ed25519/constants, libp2p/crypto/ed25519/ed25519, libp2p/crypto/hkdf, libp2p/crypto/minasn1, libp2p/crypto/rsa, libp2p/crypto/secp, libp2p/dial, libp2p/dialer, libp2p/errors, libp2p/multiaddress, libp2p/multibase, libp2p/multicodec, libp2p/multihash, libp2p/multistream, libp2p/muxers/mplex/coder, libp2p/muxers/mplex/mplex, libp2p/muxers/muxer, libp2p/muxers/yamux/yamux, libp2p/nameresolving/nameresolver, libp2p/observedaddrmanager, libp2p/peerid, libp2p/peerinfo, libp2p/protobuf/minprotobuf, libp2p/protocols/connectivity/autonat/core, libp2p/protocols/connectivity/autonat/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/ping, libp2p/protocols/protocol, libp2p/protocols/pubsub/errors, libp2p/protocols/pubsub/floodsub, libp2p/protocols/pubsub/gossipsub, libp2p/protocols/pubsub/gossipsub/behavior, 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/secure/noise, libp2p/protocols/secure/secure, libp2p/routing_record, libp2p/signed_envelope, libp2p/stream/bufferstream, libp2p/stream/chronosstream, libp2p/stream/connection, libp2p/stream/lpstream, libp2p/stream/streamseq, libp2p/switch, libp2p/transcoder, libp2p/transports/tcptransport, libp2p/transports/transport, libp2p/transports/wstransport, libp2p/upgrademngrs/muxedupgrade, libp2p/upgrademngrs/upgrade, libp2p/utility, libp2p/utils/future, libp2p/utils/heartbeat, libp2p/utils/offsettedseq, libp2p/utils/semaphore, libp2p/varint, libp2p/vbuffer, libp2p/wire.

API symbols

`$`:

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

`&=`:

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

`&`:

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

`>=`:

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

`>`:

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

`<=`:

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

`<`:

• peerid: `<`(a, b: PeerId): bool

`==`:

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

`[]`:

• multiaddress: `[]`(ma: MultiAddress; i: int | BackwardsIndex): MaResult[MultiAddress]
• multiaddress: `[]`(ma: MultiAddress; slice: HSlice): MaResult[MultiAddress]
• multiaddress: `[]`(ma: MultiAddress; codec: MultiCodec): MaResult[MultiAddress]
• offsettedseq: `[]`[T](o: var OffsettedSeq[T]; index: int): var T

accept:

• rtransport: accept(self: RelayTransport): Future[Connection]
• tcptransport: accept(self: TcpTransport): Future[Connection]
• transport: accept(self: Transport): Future[Connection]
• wstransport: accept(self: WsTransport): Future[Connection]

acquire:

• semaphore: acquire(s: AsyncSemaphore): Future[void]

add:

• streamseq: add(v: var StreamSeq; data: openArray[byte])
• offsettedseq: add[T](o: var OffsettedSeq[T]; v: T)

addCapped:

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

addConnEventHandler:

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

addDirectPeer:

• gossipsub: addDirectPeer(g: GossipSub; id: PeerId; addrs: seq[MultiAddress]): Future[void]

addedAt:

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

addHandler:

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

addObservation:

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

addObserver:

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

addPeer:

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

addPeerEventHandler:

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

AddressInfo:

• routing_record: AddressInfo

AddressLimit:

• core: AddressLimit

AddressMapper:

• peerinfo: AddressMapper

addrs:

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

addSeen:

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

addTransport:

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

addValidator:

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

advertise:

• rendezvous: advertise(rdv: RendezVous; ns: string; ttl: Duration = MinimumDuration): Future[ void]

AgentVersion:

• identify: AgentVersion

all:

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

AllFuturesFailedError:

• future: AllFuturesFailedError

AlreadyExpectingConnectionError:

• connmanager: AlreadyExpectingConnectionError

And:

• MaPatternOp.And

any:

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

anyCompleted:

• future: anyCompleted[T](futs: seq[Future[T]]): Future[Future[T]]

append:

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

apply:

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

Asn1Buffer:

• minasn1: Asn1Buffer

Asn1Class:

• minasn1: Asn1Class

Asn1Composite:

• minasn1: Asn1Composite

asn1EncodeBitString:

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

asn1EncodeBoolean:

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

asn1EncodeComposite:

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

asn1EncodeContextTag:

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

asn1EncodeInteger:

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

asn1EncodeLength:

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

asn1EncodeNull:

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

asn1EncodeOctetString:

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

asn1EncodeOid:

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

asn1EncodeSequence:

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

Asn1Error:

• minasn1: Asn1Error

Asn1False:

• minasn1: Asn1False

Asn1Field:

• minasn1: Asn1Field

Asn1Null:

• minasn1: Asn1Null

Asn1OidEcPublicKey:

• minasn1: Asn1OidEcPublicKey

Asn1OidRsaEncryption:

• minasn1: Asn1OidRsaEncryption

Asn1OidSecp256k1:

• minasn1: Asn1OidSecp256k1

Asn1OidSecp256r1:

• minasn1: Asn1OidSecp256r1

Asn1OidSecp384r1:

• minasn1: Asn1OidSecp384r1

Asn1OidSecp521r1:

• minasn1: Asn1OidSecp521r1

Asn1Result:

• minasn1: Asn1Result

Asn1Tag:

• minasn1: Asn1Tag

Asn1True:

• minasn1: Asn1True

assign:

• streamseq: assign(v: var StreamSeq; buf: openArray[byte])

AsyncSemaphore:

• semaphore: AsyncSemaphore

atEof:

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

Autonat:

• server: Autonat

AutonatCodec:

• core: AutonatCodec

AutonatDial:

• core: AutonatDial

AutonatDialResponse:

• core: AutonatDialResponse

AutonatError:

• core: AutonatError

AutonatMsg:

• core: AutonatMsg

AutonatPeerInfo:

• core: AutonatPeerInfo

AutonatUnreachableError:

• core: AutonatUnreachableError

BackoffSlackTime:

• types: BackoffSlackTime

BackoffTable:

• types: BackoffTable

BadRequest:

• ResponseStatus.BadRequest

base58:

• multihash: base58(value: MultiHash): string

BasePrecomp:

• constants: BasePrecomp

bindAsyncSocket:

• wire: bindAsyncSocket(sock: AsyncFD; ma: MultiAddress): bool

BiPrecomp:

• constants: BiPrecomp

bridge:

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

broadcast:

• pubsub: broadcast(p: PubSub; sendPeers: auto; msg: RPCMsg; isHighPriority: bool)

BufferStream:

• bufferstream: BufferStream

BufferStreamTrackerName:

• bufferstream: BufferStreamTrackerName

byScore:

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

bytes:

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

byteSize:

• messages: byteSize(msg: Message): int
• messages: byteSize(rpc: RPCMsg): int
• messages: byteSize(ihaves: seq[ControlIHave]): int
• messages: byteSize(iwants: seq[ControlIWant]): int
• messages: byteSize(msgs: seq[Message]): int

CacheEntry:

• mcache: CacheEntry

canAskIWant:

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

capLen:

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

ChaChaPoly:

• chacha20poly1305: ChaChaPoly

ChaChaPolyKey:

• chacha20poly1305: ChaChaPolyKey

ChaChaPolyNonce:

• chacha20poly1305: ChaChaPolyNonce

ChaChaPolyTag:

• chacha20poly1305: ChaChaPolyTag

checkFieldNumber:

• minprotobuf: checkFieldNumber(i: int)

checkFutures:

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

checkScalar:

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

checkValid:

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

ChronosStream:

• chronosstream: ChronosStream

ChronosStreamTrackerName:

• chronosstream: ChronosStreamTrackerName

CircuitRelay:

• multiaddress: CircuitRelay

clear:

• ecnist: clear[T: EcPKI | EcKeyPair](pki: var T)
• ed25519: clear(pair: var EdKeyPair)
• ed25519: clear(key: var EdPrivateKey)
• ed25519: clear(key: var EdPublicKey)
• ed25519: clear(sig: var EdSignature)
• rsa: clear[T: RsaPKI | RsaKeyPair](pki: var T)
• secp: clear(key: var SkPrivateKey)
• streamseq: clear(v: var StreamSeq)

close:

• connmanager: close(c: ConnManager): Future[void]
• mplex: close(m: Mplex): InternalRaisesFuture[void, void]
• muxer: close(m: Muxer): InternalRaisesFuture[void, void]
• yamux: close(m: Yamux): InternalRaisesFuture[void, void]
• lpstream: close(s: LPStream): InternalRaisesFuture[void, void]

closed:

• chronosstream: closed(s: ChronosStream): bool
• lpstream: closed(s: LPStream): bool

closeImpl:

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

closeWithEOF:

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

cmp:

• peerid: cmp(a, b: PeerId): int

code:

• minasn1: code(tag: Asn1Tag): byte

codec:

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

codec=:

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

commit:

• streamseq: commit(v: var StreamSeq; n: int)

compilesOr:

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

concat:

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

ConcurrentUpgrades:

• switch: ConcurrentUpgrades

connCount:

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

connect:

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

connected:

• pubsubpeer: connected(p: PubSubPeer): bool

connectedPeers:

• switch: connectedPeers(s: Switch; dir: Direction): seq[PeerId]

Connection:

• connection: Connection

ConnectionFailed:

• StatusV2.ConnectionFailed

ConnectionSlot:

• connmanager: ConnectionSlot

ConnectionTrackerName:

• connection: ConnectionTrackerName

ConnEvent:

• connmanager: ConnEvent

ConnEventHandler:

• connmanager: ConnEventHandler

ConnEventKind:

• connmanager: ConnEventKind

connHandler:

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

ConnManager:

• connmanager: ConnManager

consume:

• streamseq: consume(v: var StreamSeq; n: int)

consumeTo:

• streamseq: consumeTo(v: var StreamSeq; buf: var openArray[byte]): int

contains:

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

ControlGraft:

• messages: ControlGraft

ControlIHave:

• messages: ControlIHave

ControlIWant:

• messages: ControlIWant

ControlMessage:

• messages: ControlMessage

ControlPrune:

• messages: ControlPrune

copy:

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

count:

• offsettedseq: count[T](o: OffsettedSeq[T]; x: T): int
• semaphore: count(s: AsyncSemaphore): int

createAsyncSocket:

• wire: createAsyncSocket(ma: MultiAddress): AsyncFD

createStreamServer:

• wire: 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: createStreamServer[T](ma: MultiAddress; cbproc: StreamCallback; flags: set[ServerFlags] = {}; udata: ref T; sock: AsyncFD = asyncInvalidSocket; backlog: int = 100; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil): StreamServer

CryptoError:

• crypto: CryptoError

CryptoResult:

• crypto: CryptoResult

Curve25519:

• curve25519: Curve25519

Curve25519Error:

• curve25519: Curve25519Error

Curve25519Key:

• curve25519: Curve25519Key

Curve25519KeySize:

• curve25519: Curve25519KeySize

CurveOrder:

• constants: CurveOrder

Curver25519GenError:

• Curve25519Error.Curver25519GenError

D2Const:

• constants: D2Const

data:

• multiaddress: data(ma: MultiAddress): VBuffer
• streamseq: data(v: StreamSeq): openArray[byte]

DConst:

• constants: DConst

decode:

• multibase: decode(mbtype: typedesc[MultiBase]; inbytes: openArray[char]): Result[seq[byte], string]
• multibase: decode(mbtype: typedesc[MultiBase]; inbytes: openArray[char]; outbytes: var openArray[byte]; outlen: var int): MultiBaseStatus
• multihash: decode(mhtype: typedesc[MultiHash]; data: openArray[byte]; mhash: var MultiHash): MhResult[ int]
• core: decode(_: typedesc[AutonatMsg]; buf: seq[byte]): Opt[AutonatMsg]
• messages: decode(_: typedesc[HopMessage]; buf: seq[byte]): Opt[HopMessage]
• messages: decode(_: typedesc[RelayMessage]; buf: seq[byte]): Opt[RelayMessage]
• messages: decode(_: typedesc[StopMessage]; buf: seq[byte]): Opt[StopMessage]
• messages: decode(_: typedesc[Voucher]; buf: seq[byte]): Result[Voucher, ProtoError]
• routing_record: decode(T: typedesc[PeerRecord]; buffer: seq[byte]): Result[PeerRecord, ProtoError]
• signed_envelope: decode(T: typedesc[Envelope]; buf: seq[byte]; domain: string): Result[Envelope, EnvelopeError]
• signed_envelope: decode[T](_: typedesc[SignedPayload[T]]; buffer: seq[byte]): Result[ SignedPayload[T], EnvelopeError]

decodeControl:

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

decodedLength:

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

decodeGraft:

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

decodeIHave:

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

decodeIWant:

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

decodeMessage:

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

decodeMessages:

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

decodeMsg:

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

decodePeerInfoMsg:

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

decodePrune:

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

decodeRpcMsg:

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

decodeSubscription:

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

decodeSubscriptions:

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

decrypt:

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

DefaultChanTimeout:

• muxer: DefaultChanTimeout

DefaultConnectionTimeout:

• connection: DefaultConnectionTimeout

DefaultHeartbeatSleepTime:

• relay: DefaultHeartbeatSleepTime

DefaultKeySize:

• rsa: DefaultKeySize

DefaultLimitData:

• relay: DefaultLimitData

DefaultLimitDuration:

• relay: DefaultLimitDuration

DefaultMaxIncomingStreams:

• protocol: DefaultMaxIncomingStreams

DefaultMaxNumElementsInNonPriorityQueue:

• pubsubpeer: DefaultMaxNumElementsInNonPriorityQueue

defaultMsgIdProvider:

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

DefaultPublicExponent:

• rsa: DefaultPublicExponent

DefaultReservationTTL:

• relay: DefaultReservationTTL

del:

• timedcache: del[K](t: var TimedCache[K]; key: K): Opt[TimedEntry[K]]

Dial:

• dial: Dial

dial:

• dial: dial(self: Dial; peerId: PeerId; addrs: seq[MultiAddress]; protos: seq[string]; forceDial = false): Future[Connection]
• dial: dial(self: Dial; peerId: PeerId; protos: seq[string]): Future[Connection]
• dialer: dial(self: Dialer; peerId: PeerId; addrs: seq[MultiAddress]; protos: seq[string]; forceDial = false): Future[Connection]
• dialer: dial(self: Dialer; peerId: PeerId; protos: seq[string]): Future[Connection]

Dial:

• MsgType.Dial

dial:

• rtransport: dial(self: RelayTransport; ma: MultiAddress): Future[Connection]
• rtransport: dial(self: RelayTransport; hostname: string; ma: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): Future[Connection]
• switch: dial(s: Switch; peerId: PeerId; addrs: seq[MultiAddress]; proto: string): Future[ Connection]
• switch: dial(s: Switch; peerId: PeerId; proto: string): Future[Connection]
• switch: dial(s: Switch; peerId: PeerId; addrs: seq[MultiAddress]; protos: seq[string]; forceDial = false): Future[Connection]
• switch: dial(s: Switch; peerId: PeerId; protos: seq[string]): Future[Connection]
• tcptransport: dial(self: TcpTransport; hostname: string; address: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): Future[Connection]
• transport: dial(self: Transport; address: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): Future[Connection]
• transport: dial(self: Transport; hostname: string; address: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): Future[Connection]
• wstransport: dial(self: WsTransport; hostname: string; address: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): Future[Connection]

Dialer:

• dialer: Dialer

DialError:

• ResponseStatus.DialError

DialFailedError:

• dialer: DialFailedError

dialPeerV1:

• client: dialPeerV1(cl: RelayClient; conn: Connection; dstPeerId: PeerId; dstAddrs: seq[MultiAddress]): Future[Connection]

dialPeerV2:

• client: dialPeerV2(cl: RelayClient; conn: RelayConnection; dstPeerId: PeerId; dstAddrs: seq[MultiAddress]): Future[Connection]

DialRefused:

• ResponseStatus.DialRefused

DialResponse:

• MsgType.DialResponse

digest:

• multihash: digest(mhtype: typedesc[MultiHash]; hashcode: int; data: openArray[byte]): MhResult[ MultiHash]
• multihash: digest(mhtype: typedesc[MultiHash]; hashname: string; data: openArray[byte]): MhResult[ MultiHash]

DigestSheme:

• crypto: DigestSheme

Direction:

• lpstream: Direction

disconnect:

• switch: disconnect(s: Switch; peerId: PeerId): Future[void]

disconnectIfBadScorePeer:

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

disconnectPeer:

• scoring: disconnectPeer(g: GossipSub; peer: PubSubPeer): Future[void]

DNS:

• multiaddress: DNS

DNS4:

• multiaddress: DNS4

DNS6:

• multiaddress: DNS6

DNSADDR:

• multiaddress: DNSADDR

DNSANY:

• multiaddress: DNSANY

DNS_OR_IP:

• multiaddress: DNS_OR_IP

DropConn:

• pubsubpeer: DropConn

dropFanoutPeers:

• behavior: dropFanoutPeers(g: GossipSub)

dropPeer:

• connmanager: dropPeer(c: ConnManager; peerId: PeerId): Future[void]

dummyPrivateProc:

• libp2p: dummyPrivateProc()

EcCurveKind:

• ecnist: EcCurveKind

ECDHEScheme:

• ecnist: ECDHEScheme

ECDSA:

• PKScheme.ECDSA

EcError:

• ecnist: EcError

EcKeyGenError:

• EcError.EcKeyGenError

EcKeyIncorrectError:

• EcError.EcKeyIncorrectError

EcKeyPair:

• ecnist: EcKeyPair

EcPKI:

• ecnist: EcPKI

EcPrivateKey:

• ecnist: EcPrivateKey

EcPublicKey:

• ecnist: EcPublicKey

EcPublicKeyError:

• EcError.EcPublicKeyError

EcResult:

• ecnist: EcResult

EcRngError:

• EcError.EcRngError

EcSignature:

• ecnist: EcSignature

EcSignatureError:

• EcError.EcSignatureError

EcSupportedCurvesCint:

• ecnist: EcSupportedCurvesCint

Ed25519:

• PKScheme.Ed25519

EdError:

• ed25519: EdError

EdIncorrectError:

• EdError.EdIncorrectError

EdKeyPair:

• ed25519: EdKeyPair

EdPrivateKey:

• ed25519: EdPrivateKey

EdPrivateKeySize:

• ed25519: EdPrivateKeySize

EdPublicKey:

• ed25519: EdPublicKey

EdPublicKeySize:

• ed25519: EdPublicKeySize

EdSignature:

• ed25519: EdSignature

EdSignatureSize:

• ed25519: EdSignatureSize

encode:

• multiaddress: encode(mbtype: typedesc[MultiBase]; encoding: string; ma: MultiAddress): string
• multibase: encode(mbtype: typedesc[MultiBase]; encoding: string; inbytes: openArray[byte]): Result[ string, string]
• multibase: encode(mbtype: typedesc[MultiBase]; encoding: string; inbytes: openArray[byte]; outbytes: var openArray[char]; outlen: var int): MultiBaseStatus
• multihash: encode(mbtype: typedesc[MultiBase]; encoding: string; mh: MultiHash): string
• core: encode(d: AutonatDial): ProtoBuffer
• core: encode(r: AutonatDialResponse): ProtoBuffer
• core: encode(msg: AutonatMsg): ProtoBuffer
• messages: encode(msg: HopMessage): ProtoBuffer
• messages: encode(msg: RelayMessage): ProtoBuffer
• messages: encode(msg: StopMessage): ProtoBuffer
• messages: encode(v: Voucher): seq[byte]
• routing_record: encode(record: PeerRecord): seq[byte]
• signed_envelope: encode(env: Envelope): Result[seq[byte], CryptoError]
• signed_envelope: encode[T](msg: SignedPayload[T]): Result[seq[byte], CryptoError]

encodedLength:

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

encodeMessage:

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

encodeRpcMsg:

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

encodeVarint:

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

encrypt:

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

EndGroup:

• ProtoFieldKind.EndGroup

Envelope:

• signed_envelope: Envelope

EnvelopeError:

• signed_envelope: EnvelopeError

EnvelopeFieldMissing:

• EnvelopeError.EnvelopeFieldMissing

EnvelopeInvalidProtobuf:

• EnvelopeError.EnvelopeInvalidProtobuf

EnvelopeInvalidSignature:

• EnvelopeError.EnvelopeInvalidSignature

EnvelopeWrongType:

• EnvelopeError.EnvelopeWrongType

Eof:

• lpstream: Eof

ephemeral:

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

Eq:

• MaPatternOp.Eq

exceptionToAssert:

• utility: exceptionToAssert(body: untyped): untyped

expandItIMPL:

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

expectConnection:

• connmanager: expectConnection(c: ConnManager; p: PeerId; dir: Direction): Future[Muxer]

expire:

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

extend:

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

extractPublicKey:

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

Fe:

• constants: Fe

finish:

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

firstSeen:

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

Fixed:

• MAKind.Fixed

Fixed32:

• ProtoFieldKind.Fixed32

Fixed64:

• ProtoFieldKind.Fixed64

FloodSub:

• floodsub: FloodSub

FloodSubCodec:

• floodsub: FloodSubCodec

flushIf:

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

flushIfIt:

• offsettedseq: flushIfIt(o, pred: untyped)

forceAcquire:

• semaphore: forceAcquire(s: AsyncSemaphore)

formatItIMPL:

• mplex: formatItIMPL(it: Mplex): auto
• muxer: formatItIMPL(it: Muxer): auto
• peerid: formatItIMPL(it: PeerId): auto
• peerinfo: formatItIMPL(it: PeerInfo): auto
• pubsubpeer: formatItIMPL(it: PubSubPeer): auto
• noise: formatItIMPL(it: NoiseConnection): auto
• secure: formatItIMPL(it: SecureConn): auto
• bufferstream: formatItIMPL(it: BufferStream): auto
• chronosstream: formatItIMPL(it: ChronosStream): auto
• connection: formatItIMPL(it: Connection): auto
• lpstream: formatItIMPL(it: LPStream): auto

fullAddrs:

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

GeCached:

• constants: GeCached

GeP1P1:

• constants: GeP1P1

GeP2:

• constants: GeP2

GeP3:

• constants: GeP3

GePrecomp:

• constants: GePrecomp

get:

• mcache: get(c: MCache; msgId: MessageId): Opt[Message]

getAgent:

• pubsubpeer: getAgent(peer: PubSubPeer): string

getArray:

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

getBuffer:

• minasn1: getBuffer(field: Asn1Field): Asn1Buffer

getBytes:

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

GetConn:

• pubsubpeer: GetConn

getConnections:

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

getField:

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

getGossipPeers:

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

getHostname:

• nameresolver: getHostname(ma: MultiAddress): string

getIncomingSlot:

• connmanager: getIncomingSlot(c: ConnManager): Future[ConnectionSlot]

getLen:

• minprotobuf: getLen(pb: ProtoBuffer): int

getLocalAddress:

• wire: getLocalAddress(sock: AsyncFD): TransportAddress

getMostObservedProtosAndPorts:

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

getOrCreatePeer:

• gossipsub: getOrCreatePeer(g: GossipSub; peerId: PeerId; protos: seq[string]): PubSubPeer
• pubsub: getOrCreatePeer(p: PubSub; peerId: PeerId; protos: seq[string]): PubSubPeer

getOrder:

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

getOutgoingSlot:

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

getPackedRepeatedField:

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

getPrivateKeyLength:

• ecnist: getPrivateKeyLength(curve: EcCurveKind): int

getProtoHeader:

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

getPtr:

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

getPublicKey:

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

getPublicKeyLength:

• ecnist: getPublicKeyLength(curve: EcCurveKind): int

getRawBytes:

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

getRepeatedField:

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

getRequiredField:

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

getRequiredRepeatedField:

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

getSecret:

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

getStream:

• connmanager: getStream(c: ConnManager; muxer: Muxer): Future[Connection]
• connmanager: getStream(c: ConnManager; peerId: PeerId): Future[Connection]
• connmanager: getStream(c: ConnManager; peerId: PeerId; dir: Direction): Future[Connection]

getStreams:

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

getSVarint:

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

getUVarint:

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

getVarint:

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

getWrapped:

• yamux: getWrapped(channel: YamuxChannel): Connection
• rconn: getWrapped(self: RelayConnection): Connection
• secure: getWrapped(s: SecureConn): Connection
• chronosstream: getWrapped(s: ChronosStream): Connection
• connection: getWrapped(s: Connection): Connection
• wstransport: getWrapped(s: WsStream): Connection

goffset:

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

GossipBackoffPeriod:

• types: GossipBackoffPeriod

GossipSub:

• types: GossipSub

GossipSubCodec_10:

• types: GossipSubCodec_10

GossipSubCodec_11:

• types: GossipSubCodec_11

GossipSubD:

• types: GossipSubD

GossipSubDhi:

• types: GossipSubDhi

GossipSubDlo:

• types: GossipSubDlo

GossipSubFanoutTTL:

• types: GossipSubFanoutTTL

GossipSubHeartbeatInterval:

• types: GossipSubHeartbeatInterval

GossipSubHistoryGossip:

• types: GossipSubHistoryGossip

GossipSubHistoryLength:

• types: GossipSubHistoryLength

GossipSubParams:

• types: GossipSubParams

grafted:

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

guessDialableAddr:

• observedaddrmanager: guessDialableAddr(self: ObservedAddrManager; ma: MultiAddress): MultiAddress

handle:

• multistream: handle(m: MultistreamSelect; conn: Connection; active: bool = false): InternalRaisesFuture[ void, (CancelledError,)]
• multistream: handle(_: type MultistreamSelect; conn: Connection; protos: seq[string]; matchers = newSeq[Matcher](); active: bool = false): InternalRaisesFuture[ string, (CancelledError, LPStreamError, MultiStreamError)]
• muxer: handle(m: Muxer): InternalRaisesFuture[void, void]
• yamux: handle(m: Yamux): InternalRaisesFuture[void, void]
• pubsubpeer: handle(p: PubSubPeer; conn: Connection): Future[void]

handleBackingOff:

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

handleConn:

• pubsub: handleConn(p: PubSub; conn: Connection; proto: string): Future[void]

handleData:

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

handleGraft:

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

handleHop:

• relay: handleHop(r: Relay; connSrc: Connection; msg: RelayMessage): Future[void]

handleHopStreamV2:

• relay: handleHopStreamV2(r: Relay; conn: Connection): Future[void]

handleIDontWant:

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

handleIHave:

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

handleIWant:

• behavior: handleIWant(g: GossipSub; peer: PubSubPeer; iwants: seq[ControlIWant]): seq[ Message]

handlePrune:

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

handler:

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

handler=:

• protocol: handler=(p: LPProtocol; handler: LPProtoHandler)
• protocol: handler=[E](p: LPProtocol; handler: proc (conn: Connection; proto: string): InternalRaisesFuture[ void, E])

HandlerHolder:

• multistream: HandlerHolder

handles:

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

handshake:

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

hash:

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

HashError:

• CryptoError.HashError

hasObservers:

• pubsubpeer: hasObservers(p: PubSubPeer): bool

hasPeer:

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

hasPeerId:

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

hasPublicKey:

• peerid: hasPublicKey(pid: PeerId): bool

hasSeen:

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

hasSendConn:

• pubsubpeer: hasSendConn(p: PubSubPeer): bool

heartbeat:

• behavior: heartbeat(g: GossipSub): Future[void]
• heartbeat: heartbeat(name: string; interval: Duration; body: untyped): untyped

hex:

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

high:

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

hint:

• varint: hint

hint32:

• varint: hint32

hint64:

• varint: hint64

hkdf:

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

HkdfResult:

• hkdf: HkdfResult

HopMessage:

• messages: HopMessage

HopMessageType:

• messages: HopMessageType

HTTP:

• multiaddress: HTTP

HTTPS:

• multiaddress: HTTPS

Identify:

• identify: Identify

identify:

• identify: identify(self: Identify; conn: Connection; remotePeerId: PeerId): Future[ IdentifyInfo]

IdentifyCodec:

• identify: IdentifyCodec

IdentifyError:

• identify: IdentifyError

IdentifyInfo:

• identify: IdentifyInfo

IdentifyNoPubKeyError:

• identify: IdentifyNoPubKeyError

IdentifyPush:

• identify: IdentifyPush

IdentifyPushCodec:

• identify: IdentifyPushCodec

IdentifyPushHandler:

• identify: IdentifyPushHandler

IdentityInvalidMsgError:

• identify: IdentityInvalidMsgError

IdentityNoMatchError:

• identify: IdentityNoMatchError

IHaveMaxLength:

• types: IHaveMaxLength

IHavePeerBudget:

• types: IHavePeerBudget

init:

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

init58:

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

InitializationError:

• pubsub: InitializationError

initOffsettedSeq:

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

initProtoBuffer:

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

initPubSub:

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

initRaw:

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

initStream:

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

initTAddress:

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

initVBuffer:

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

InternalError:

• ResponseStatus.InternalError

intoChaChaPolyKey:

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

intoChaChaPolyNonce:

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

intoChaChaPolyTag:

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

intoCurve25519Key:

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

InvalidChannelIdError:

• mplex: InvalidChannelIdError

InvalidMplexMsgType:

• coder: InvalidMplexMsgType

InvalidMultiCodec:

• multicodec: InvalidMultiCodec

InvalidVarintError:

• lpstream: InvalidVarintError

IP:

• multiaddress: IP

IP4:

• multiaddress: IP4

IP6:

• multiaddress: IP6

IPFS:

• multiaddress: IPFS

IpTransportProtocol:

• multiaddress: IpTransportProtocol

isConnected:

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

isEmpty:

• minasn1: isEmpty(ab: Asn1Buffer): bool
• multiaddress: isEmpty(ma: MultiAddress): bool
• minprotobuf: isEmpty(pb: ProtoBuffer): bool
• vbuffer: isEmpty(vb: VBuffer): bool

isEnough:

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

isPublicMA:

• wire: isPublicMA(ma: MultiAddress): bool

isRelayed:

• relay: isRelayed(conn: Connection): bool

items:

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

iv:

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

ivOpenArray:

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

join:

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

key:

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

KeyError:

• CryptoError.KeyError

keyOpenArray:

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

KeyPair:

• crypto: KeyPair

KnownLibP2PTopics:

• pubsub: KnownLibP2PTopics

KnownLibP2PTopicsSeq:

• pubsub: KnownLibP2PTopicsSeq

len:

• minasn1: len(field: Asn1Field): int
• minasn1: len[T: Asn1Buffer | Asn1Composite](abc: T): int
• multiaddress: len(ma: MultiAddress): MaResult[int]
• peerid: len(pid: PeerId): int
• bufferstream: len(s: BufferStream): int
• streamseq: len(v: StreamSeq): int
• vbuffer: len(vb: VBuffer): int

Length:

• MAKind.Length
• ProtoFieldKind.Length

libp2p_failed_upgrades_incoming:

• upgrade: libp2p_failed_upgrades_incoming

libp2p_failed_upgrades_outgoing:

• upgrade: libp2p_failed_upgrades_outgoing

libp2p_gossipsub_peers_rate_limit_hits:

• scoring: libp2p_gossipsub_peers_rate_limit_hits

libp2p_pki_schemes:

• crypto: libp2p_pki_schemes

libp2p_pubsub_broadcast_graft:

• pubsub: libp2p_pubsub_broadcast_graft

libp2p_pubsub_broadcast_ihave:

• pubsub: libp2p_pubsub_broadcast_ihave

libp2p_pubsub_broadcast_iwant:

• pubsub: libp2p_pubsub_broadcast_iwant

libp2p_pubsub_broadcast_messages:

• pubsub: libp2p_pubsub_broadcast_messages

libp2p_pubsub_broadcast_prune:

• pubsub: libp2p_pubsub_broadcast_prune

libp2p_pubsub_broadcast_subscriptions:

• pubsub: libp2p_pubsub_broadcast_subscriptions

libp2p_pubsub_broadcast_unsubscriptions:

• pubsub: libp2p_pubsub_broadcast_unsubscriptions

libp2p_pubsub_messages_published:

• pubsub: libp2p_pubsub_messages_published

libp2p_pubsub_messages_rebroadcasted:

• pubsub: libp2p_pubsub_messages_rebroadcasted

libp2p_pubsub_received_graft:

• pubsub: libp2p_pubsub_received_graft

libp2p_pubsub_received_ihave:

• pubsub: libp2p_pubsub_received_ihave

libp2p_pubsub_received_iwant:

• pubsub: libp2p_pubsub_received_iwant

libp2p_pubsub_received_messages:

• pubsub: libp2p_pubsub_received_messages

libp2p_pubsub_received_prune:

• pubsub: libp2p_pubsub_received_prune

libp2p_pubsub_received_subscriptions:

• pubsub: libp2p_pubsub_received_subscriptions

libp2p_pubsub_received_unsubscriptions:

• pubsub: libp2p_pubsub_received_unsubscriptions

Limit:

• messages: Limit

list:

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

low:

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

LP:

• varint: LP

LPError:

• errors: LPError

LPProtocol:

• protocol: LPProtocol

LPProtoHandler:

• protocol: LPProtoHandler

LPSomeUVarint:

• varint: LPSomeUVarint

LPSomeVarint:

• varint: LPSomeVarint

LPStream:

• lpstream: LPStream

LPStreamClosedError:

• lpstream: LPStreamClosedError

LPStreamConnDownError:

• lpstream: LPStreamConnDownError

LPStreamEOFError:

• lpstream: LPStreamEOFError

LPStreamError:

• lpstream: LPStreamError

LPStreamIncompleteError:

• lpstream: LPStreamIncompleteError

LPStreamLimitError:

• lpstream: LPStreamLimitError

LPStreamRemoteClosedError:

• lpstream: LPStreamRemoteClosedError

LPStreamResetError:

• lpstream: LPStreamResetError

LPStreamTrackerName:

• lpstream: LPStreamTrackerName

mac:

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

macOpenArray:

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

MaError:

• multiaddress: MaError

MaInvalidAddress:

• multiaddress: MaInvalidAddress

MAKind:

• multiaddress: MAKind

MalformedMessage:

• StatusV2.MalformedMessage

mapAnd:

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

MaPatResult:

• multiaddress: MaPatResult

MaPattern:

• multiaddress: MaPattern

MaPatternOp:

• multiaddress: MaPatternOp

mapEq:

• multiaddress: mapEq(codec: string): MaPattern

mapOr:

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

MAProtocol:

• multiaddress: MAProtocol

MaResult:

• multiaddress: MaResult

Marker:

• MAKind.Marker

match:

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

Matcher:

• multistream: Matcher

matchPartial:

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

MaxCircuit:

• relay: MaxCircuit

MaxCircuitPerPeer:

• relay: MaxCircuitPerPeer

MaxConnections:

• connmanager: MaxConnections

MaxConnectionsPerPeer:

• connmanager: MaxConnectionsPerPeer

MaxHashSize:

• multihash: MaxHashSize

maxIncomingStreams:

• protocol: maxIncomingStreams(p: LPProtocol): int

maxIncomingStreams=:

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

maxInlineKeyLength:

• peerid: maxInlineKeyLength

MaxMsgSize:

• coder: MaxMsgSize

MaxSizeError:

• lpstream: MaxSizeError

MCache:

• mcache: MCache

MeshMetrics:

• types: MeshMetrics

Message:

• messages: Message

MessageId:

• messages: MessageId

MessageType:

• coder: MessageType

MHash:

• multihash: MHash

MHashCoderProc:

• multihash: MHashCoderProc

MhResult:

• multihash: MhResult

MinimumDuration:

• rendezvous: MinimumDuration

MinKeySize:

• rsa: MinKeySize

mount:

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

Mplex:

• mplex: Mplex

MplexCodec:

• mplex: MplexCodec

Msg:

• coder: Msg

MsgIdProvider:

• pubsub: MsgIdProvider

MsgType:

• core: MsgType

mul:

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

MultiAddress:

• multiaddress: MultiAddress

MultiBase:

• multibase: MultiBase

MultiBaseStatus:

• multibase: MultiBaseStatus

MultiCodec:

• multicodec: MultiCodec

multiCodec:

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

MultiCodecError:

• multicodec: MultiCodecError

MultiCodecNotSupported:

• MultiCodecError.MultiCodecNotSupported

MultiHash:

• multihash: MultiHash

MultiStreamError:

• multistream: MultiStreamError

MultistreamSelect:

• multistream: MultistreamSelect

MuxedUpgrade:

• muxedupgrade: MuxedUpgrade

Muxer:

• muxer: Muxer

MuxerConstructor:

• muxer: MuxerConstructor

MuxerError:

• muxer: MuxerError

MuxerHandler:

• muxer: MuxerHandler

MuxerProvider:

• muxer: MuxerProvider

NameResolver:

• nameresolver: NameResolver

NetworkReachability:

• core: NetworkReachability

new:

• builders: new(T: type[SwitchBuilder]): T:type
• connmanager: new(C: type ConnManager; maxConnsPerPeer = MaxConnectionsPerPeer; maxConnections = MaxConnections; maxIn = -1; maxOut = -1): ConnManager
• dialer: new(T: type Dialer; localPeerId: PeerId; connManager: ConnManager; peerStore: PeerStore; transports: seq[Transport]; nameResolver: NameResolver = nil): Dialer
• multistream: new(T: typedesc[MultistreamSelect]): T:type
• mplex: new(M: type Mplex; conn: Connection; inTimeout: Duration = DefaultChanTimeout; outTimeout: Duration = DefaultChanTimeout; maxChannCount: int = MaxChannelCount): Mplex
• muxer: new(T: typedesc[MuxerProvider]; creator: MuxerConstructor; codec: string): T:type
• yamux: new(T: type[Yamux]; conn: Connection; maxChannCount: int = MaxChannelCount; windowSize: int = YamuxDefaultWindowSize; maxSendQueueSize: int = MaxSendQueueSize; inTimeout: Duration = 5.minutes; outTimeout: Duration = 5.minutes): T:type
• observedaddrmanager: new(T: typedesc[ObservedAddrManager]; maxSize = 10; minCount = 3): T:type
• peerinfo: new(p: typedesc[PeerInfo]; key: PrivateKey; listenAddrs: openArray[MultiAddress] = []; protocols: openArray[string] = []; protoVersion: string = ""; agentVersion: string = ""; addressMappers = newSeq[AddressMapper]()): PeerInfo
• server: new(T: typedesc[Autonat]; switch: Switch; semSize: int = 1; dialTimeout = 15.seconds): T:type
• client: 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: new(T: typedesc[RelayConnection]; conn: Connection; limitDuration: uint32; limitData: uint64): T:type
• relay: 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: new(T: typedesc[RelayTransport]; cl: RelayClient; upgrader: Upgrade): T:type
• identify: new(T: typedesc[Identify]; peerInfo: PeerInfo; sendSignedPeerRecord = false; observedAddrManager = ObservedAddrManager.new()): T:type
• identify: new(T: typedesc[IdentifyPush]; handler: IdentifyPushHandler = nil): T:type
• ping: new(T: typedesc[Ping]; handler: PingHandler = nil; rng: ref HmacDrbgContext = newRng()): T:type
• protocol: new(T: type LPProtocol; codecs: seq[string]; handler: LPProtoHandler; maxIncomingStreams: Opt[int] | int = Opt.none(int)): T:type
• protocol: new[E](T: type LPProtocol; codecs: seq[string]; handler: proc (conn: Connection; proto: string): InternalRaisesFuture[void, E]; maxIncomingStreams: Opt[int] | int = Opt.none(int)): T:type
• pubsubpeer: new(T: typedesc[PubSubPeer]; peerId: PeerId; getConn: GetConn; onEvent: OnEvent; codec: string; maxMessageSize: int; maxNumElementsInNonPriorityQueue: int = DefaultMaxNumElementsInNonPriorityQueue; overheadRateLimitOpt: Opt[TokenBucket] = Opt.none(TokenBucket)): T:type
• rendezvous: new(T: typedesc[RendezVous]; rng: ref HmacDrbgContext = newRng()): T:type
• rendezvous: new(T: typedesc[RendezVous]; switch: Switch; rng: ref HmacDrbgContext = newRng()): T:type
• noise: new(T: typedesc[Noise]; rng: ref HmacDrbgContext; privateKey: PrivateKey; outgoing: bool = true; commonPrologue: seq[byte] = @[]): T:type
• secure: new(T: type SecureConn; conn: Connection; peerId: PeerId; observedAddr: Opt[MultiAddress]; timeout: Duration = DefaultConnectionTimeout): T:type
• bufferstream: new(T: typedesc[BufferStream]; timeout: Duration = DefaultConnectionTimeout): T:type
• connection: new(C: type Connection; peerId: PeerId; dir: Direction; observedAddr: Opt[MultiAddress]; timeout: Duration = DefaultConnectionTimeout; timeoutHandler: TimeoutHandler = nil): Connection
• tcptransport: new(T: typedesc[TcpTransport]; flags: set[ServerFlags] = {}; upgrade: Upgrade; connectionsTimeout = 10.minutes): T:type
• wstransport: new(T: typedesc[WsTransport]; upgrade: Upgrade; flags: set[ServerFlags] = {}; factories: openArray[ExtFactory] = []; rng: ref HmacDrbgContext = nil; handshakeTimeout = DefaultHeadersTimeout): T:type
• wstransport: new(T: typedesc[WsTransport]; upgrade: Upgrade; tlsPrivateKey: TLSPrivateKey; tlsCertificate: TLSCertificate; tlsFlags: set[TLSFlags] = {}; flags: set[ServerFlags] = {}; factories: openArray[ExtFactory] = []; rng: ref HmacDrbgContext = nil; handshakeTimeout = DefaultHeadersTimeout): T:type
• wstransport: new(T: type WsStream; session: WSSession; dir: Direction; observedAddr: Opt[MultiAddress]; timeout = 10.minutes): T:type
• muxedupgrade: new(T: type MuxedUpgrade; muxers: seq[MuxerProvider]; secureManagers: openArray[Secure] = []; ms: MultistreamSelect): T:type

newAsyncSemaphore:

• semaphore: newAsyncSemaphore(size: int): AsyncSemaphore

newInvalidMplexMsgType:

• coder: newInvalidMplexMsgType(): ref InvalidMplexMsgType

newLPStreamClosedError:

• lpstream: newLPStreamClosedError(): ref LPStreamClosedError

newLPStreamConnDownError:

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

newLPStreamEOFError:

• lpstream: newLPStreamEOFError(): ref LPStreamEOFError

newLPStreamIncompleteError:

• lpstream: newLPStreamIncompleteError(): ref LPStreamIncompleteError

newLPStreamLimitError:

• lpstream: newLPStreamLimitError(): ref LPStreamLimitError

newLPStreamRemoteClosedError:

• lpstream: newLPStreamRemoteClosedError(): ref LPStreamRemoteClosedError

newLPStreamResetError:

• lpstream: newLPStreamResetError(): ref LPStreamResetError

newRng:

• crypto: newRng(): ref HmacDrbgContext

newStandardSwitch:

• builders: newStandardSwitch(privKey = none(PrivateKey); addrs: MultiAddress | seq[MultiAddress] = init(MultiAddress, "/ip4/127.0.0.1/tcp/0").expect( "valid address"); secureManagers: openArray[SecureProtocol] = [ SecureProtocol.Noise]; transportFlags: set[ServerFlags] = {}; rng = newRng(); inTimeout: Duration = 5.minutes; outTimeout: Duration = 5.minutes; maxConnections = MaxConnections; maxIn = -1; maxOut = -1; maxConnsPerPeer = MaxConnectionsPerPeer; nameResolver: NameResolver = nil; sendSignedPeerRecord = false; peerStoreCapacity = 1000): Switch

newStream:

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

newSwitch:

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

newTransportClosedError:

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

Noise:

• noise: Noise

NoiseCodec:

• noise: NoiseCodec

NoiseConnection:

• noise: NoiseConnection

NoiseDecryptTagError:

• noise: NoiseDecryptTagError

NoiseError:

• noise: NoiseError

NoiseHandshakeError:

• noise: NoiseHandshakeError

NoiseNonceMaxError:

• noise: NoiseNonceMaxError

NoiseOversizedPayloadError:

• noise: NoiseOversizedPayloadError

None:

• MAKind.None

NoReservation:

• StatusV2.NoReservation

ObservedAddrManager:

• observedaddrmanager: ObservedAddrManager

OffsettedSeq:

• offsettedseq: OffsettedSeq

Ok:

• ResponseStatus.Ok
• StatusV2.Ok

OnEvent:

• pubsubpeer: OnEvent

Onion3:

• multiaddress: Onion3

onNewPeer:

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

onPubSubPeerEvent:

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

onTopicSubscription:

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

Or:

• MaPatternOp.Or

orError:

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

outbound:

• pubsubpeer: outbound(p: PubSubPeer): bool

outboundPeers:

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

P2PPattern:

• multiaddress: P2PPattern

parseFullAddress:

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

Path:

• MAKind.Path

payload:

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

payloadDomain:

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

payloadType:

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

PB:

• varint: PB

PBSomeSVarint:

• varint: PBSomeSVarint

PBSomeUVarint:

• varint: PBSomeUVarint

PBSomeVarint:

• varint: PBSomeVarint

PBZigVarint:

• varint: PBZigVarint

peekArray:

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

peekSeq:

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

peekVarint:

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

Peer:

• messages: Peer

PeerEvent:

• connmanager: PeerEvent

PeerEventHandler:

• connmanager: PeerEventHandler

PeerEventKind:

• connmanager: PeerEventKind

peerExchangeList:

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

PeerId:

• peerid: PeerId

PeerInfo:

• peerinfo: PeerInfo

PeerInfoError:

• peerinfo: PeerInfoError

PeerInfoMsg:

• messages: PeerInfoMsg

PeerRateLimitError:

• pubsubpeer: PeerRateLimitError

PeerRecord:

• routing_record: PeerRecord

peers:

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

PeerStats:

• types: PeerStats

PeerTable:

• peertable: PeerTable

PermissionDenied:

• StatusV2.PermissionDenied

Ping:

• ping: Ping

ping:

• ping: ping(p: Ping; conn: Connection): Future[Duration]

PingCodec:

• ping: PingCodec

PingError:

• ping: PingError

PingHandler:

• ping: PingHandler

PingsPeerBudget:

• types: PingsPeerBudget

PKScheme:

• crypto: PKScheme

prepare:

• streamseq: prepare(v: var StreamSeq; n: int): var openArray[byte]

PrivateKey:

• crypto: PrivateKey

protoAddress:

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

protoArgument:

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

ProtoBuffer:

• minprotobuf: ProtoBuffer

protoCode:

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

protocols:

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

ProtoError:

• minprotobuf: ProtoError

ProtoField:

• minprotobuf: ProtoField

ProtoFieldKind:

• minprotobuf: ProtoFieldKind

ProtoFlags:

• minprotobuf: ProtoFlags

ProtoHeader:

• minprotobuf: ProtoHeader

protoName:

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

ProtoResult:

• minprotobuf: ProtoResult

ProtoScalar:

• minprotobuf: ProtoScalar

ProtoVersion:

• identify: ProtoVersion

pruned:

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

pubkey:

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

PubKey256Length:

• ecnist: PubKey256Length

PubKey384Length:

• ecnist: PubKey384Length

PubKey521Length:

• ecnist: PubKey521Length

public:

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

PublicKey:

• crypto: PublicKey

publish:

• floodsub: publish(f: FloodSub; topic: string; data: seq[byte]): Future[int]
• gossipsub: publish(g: GossipSub; topic: string; data: seq[byte]): Future[int]
• pubsub: publish(p: PubSub; topic: string; data: seq[byte]): Future[int]

PubSub:

• pubsub: PubSub

PubSubObserver:

• pubsubpeer: PubSubObserver

PubSubPeer:

• pubsubpeer: PubSubPeer

PubSubPeerEvent:

• pubsubpeer: PubSubPeerEvent

PubSubPeerEventKind:

• pubsubpeer: PubSubPeerEventKind

punishInvalidMessage:

• scoring: punishInvalidMessage(g: GossipSub; peer: PubSubPeer; msg: Message): Future[void]

push:

• identify: push(p: IdentifyPush; peerInfo: PeerInfo; conn: Connection): Future[void]

pushData:

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

pushEof:

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

put:

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

putSVarint:

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

putUVarint:

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

putVarint:

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

QUIC:

• multiaddress: QUIC

random:

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

rateLimit:

• gossipsub: rateLimit(g: GossipSub; peer: PubSubPeer; overhead: int): Future[void]

read:

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

readArray:

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

readExactly:

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

readLine:

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

readLp:

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

readMessage:

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

readMsg:

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

readOnce:

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

readSeq:

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

readVarint:

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

rebalanceMesh:

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

recvObservers:

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

Relay:

• relay: Relay

RelayClient:

• client: RelayClient

RelayClientAddConn:

• client: RelayClientAddConn

RelayClientError:

• client: RelayClientError

RelayConnection:

• rconn: RelayConnection

RelayMessage:

• messages: RelayMessage

RelayMsgSize:

• relay: RelayMsgSize

RelayPeer:

• messages: RelayPeer

RelayTransport:

• rtransport: RelayTransport

RelayType:

• messages: RelayType

RelayV1Codec:

• utils: RelayV1Codec

RelayV1DialError:

• client: RelayV1DialError

RelayV2DialError:

• client: RelayV2DialError

RelayV2Error:

• relay: RelayV2Error

RelayV2HopCodec:

• utils: RelayV2HopCodec

RelayV2StopCodec:

• utils: RelayV2StopCodec

release:

• connmanager: release(cs: ConnectionSlot)
• semaphore: release(s: AsyncSemaphore)

Reliable:

• multiaddress: Reliable

removeConnEventHandler:

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

removeObserver:

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

removePeer:

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

removePeerEventHandler:

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

removeValidator:

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

RendezVous:

• rendezvous: RendezVous

RendezVousCodec:

• rendezvous: RendezVousCodec

RendezVousError:

• rendezvous: RendezVousError

replenishFanout:

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

request:

• rendezvous: request(rdv: RendezVous; ns: string; l: int = 1000'u64.int): Future[ seq[PeerRecord]]

requestLocally:

• rendezvous: requestLocally(rdv: RendezVous; ns: string): seq[PeerRecord]

Reservation:

• messages: Reservation

ReservationError:

• client: ReservationError

ReservationRefused:

• StatusV2.ReservationRefused

reserve:

• client: reserve(cl: RelayClient; peerId: PeerId; addrs: seq[MultiAddress] = @[]): Future[ Rsvp]

resolveDnsAddr:

• nameresolver: resolveDnsAddr(self: NameResolver; ma: MultiAddress; depth: int = 0): Future[ seq[MultiAddress]]

resolveIp:

• nameresolver: resolveIp(self: NameResolver; address: string; port: Port; domain: Domain = Domain.AF_UNSPEC): Future[seq[TransportAddress]]

resolveMAddress:

• nameresolver: resolveMAddress(self: NameResolver; address: MultiAddress): Future[ seq[MultiAddress]]

resolveTxt:

• nameresolver: resolveTxt(self: NameResolver; address: string): Future[seq[string]]

ResourceLimitExceeded:

• StatusV2.ResourceLimitExceeded

ResponseStatus:

• core: ResponseStatus

rewardDelivered:

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

RoutingRecordsHandler:

• types: RoutingRecordsHandler

RoutingRecordsPair:

• types: RoutingRecordsPair

rpcHandler:

• floodsub: rpcHandler(f: FloodSub; peer: PubSubPeer; data: seq[byte]): Future[void]
• gossipsub: rpcHandler(g: GossipSub; peer: PubSubPeer; data: seq[byte]): Future[void]
• pubsub: rpcHandler(p: PubSub; peer: PubSubPeer; data: seq[byte]): Future[void]

RPCHandler:

• pubsubpeer: RPCHandler

RpcMessageQueue:

• pubsubpeer: RpcMessageQueue

RPCMsg:

• messages: RPCMsg

RSA:

• PKScheme.RSA

RsaDefaultKeySize:

• crypto: RsaDefaultKeySize

RsaError:

• rsa: RsaError

RsaGenError:

• RsaError.RsaGenError

RsaKeyIncorrectError:

• RsaError.RsaKeyIncorrectError

RsaKeyPair:

• rsa: RsaKeyPair

RsaKP:

• rsa: RsaKP

RsaLowSecurityError:

• RsaError.RsaLowSecurityError

RsaOidSha1:

• rsa: RsaOidSha1

RsaOidSha224:

• rsa: RsaOidSha224

RsaOidSha256:

• rsa: RsaOidSha256

RsaOidSha384:

• rsa: RsaOidSha384

RsaOidSha512:

• rsa: RsaOidSha512

RsaPKI:

• rsa: RsaPKI

RsaPrivateKey:

• rsa: RsaPrivateKey

RsaPublicKey:

• rsa: RsaPublicKey

RsaResult:

• rsa: RsaResult

RsaSignature:

• rsa: RsaSignature

RsaSignatureError:

• RsaError.RsaSignatureError

Rsvp:

• client: Rsvp

RTRANSPMA:

• wire: RTRANSPMA

run:

• switch: run(self: Service; switch: Switch): Future[void]

safeConvert:

• utility: safeConvert[T: SomeInteger; S: Ordinal](value: S): T

salt:

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

SaltedId:

• messages: SaltedId

scalarMul:

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

SchemeError:

• CryptoError.SchemeError

scoringHeartbeat:

• scoring: scoringHeartbeat(g: GossipSub): Future[void]

seckey:

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

SecKey256Length:

• ecnist: SecKey256Length

SecKey384Length:

• ecnist: SecKey384Length

SecKey521Length:

• ecnist: SecKey521Length

Secp256k1:

• PKScheme.Secp256k1

Secp256r1:

• EcCurveKind.Secp256r1

Secp384r1:

• EcCurveKind.Secp384r1

Secp521r1:

• EcCurveKind.Secp521r1

Secret:

• crypto: Secret

Secret256Length:

• ecnist: Secret256Length

Secret384Length:

• ecnist: Secret384Length

Secret521Length:

• ecnist: Secret521Length

Secure:

• secure: Secure

secure:

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

SecureConn:

• secure: SecureConn

SecureConnTrackerName:

• secure: SecureConnTrackerName

SecureProtocol:

• builders: SecureProtocol

select:

• multistream: select(_: MultistreamSelect | type MultistreamSelect; conn: Connection; proto: seq[string]): InternalRaisesFuture[string, (CancelledError, LPStreamError, MultiStreamError)]
• multistream: select(_: MultistreamSelect | type MultistreamSelect; conn: Connection; proto: string): InternalRaisesFuture[bool, (CancelledError, LPStreamError, MultiStreamError)]
• multistream: select(m: MultistreamSelect; conn: Connection): InternalRaisesFuture[bool, (CancelledError, LPStreamError, MultiStreamError)]

selectBest:

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

selectMuxer:

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

send:

• pubsub: send(p: PubSub; peer: PubSubPeer; msg: RPCMsg; isHighPriority: bool)
• pubsubpeer: send(p: PubSubPeer; msg: RPCMsg; anonymize: bool; isHighPriority: bool)

sendEncoded:

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

sendHopStatus:

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

sendStatus:

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

sendStopStatus:

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

sendSubs:

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

Service:

• switch: Service

setMaxRecvWindow:

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

setup:

• relay: setup(r: Relay; switch: Switch)
• rendezvous: setup(rdv: RendezVous; switch: Switch)
• switch: setup(self: Service; switch: Switch): Future[bool]

Sha256:

• DigestSheme.Sha256

Sha512:

• DigestSheme.Sha512

shift:

• mcache: shift(c: var MCache)

shortLog:

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

shuffle:

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

Sig256Length:

• ecnist: Sig256Length

Sig384Length:

• ecnist: Sig384Length

Sig521Length:

• ecnist: Sig521Length

SigError:

• CryptoError.SigError

sign:

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

Signature:

• crypto: Signature

SignedPayload:

• signed_envelope: SignedPayload

SignedPeerRecord:

• routing_record: SignedPeerRecord

SignedVoucher:

• messages: SignedVoucher

SkKeyPair:

• secp: SkKeyPair

SkPrivateKey:

• secp: SkPrivateKey

SkPublicKey:

• secp: SkPublicKey

SkRawPrivateKeySize:

• secp: SkRawPrivateKeySize

SkRawPublicKeySize:

• secp: SkRawPublicKeySize

SkRawSignatureSize:

• secp: SkRawSignatureSize

SkSignature:

• secp: SkSignature

SomeUVarint:

• varint: SomeUVarint

SomeVarint:

• varint: SomeVarint

SqrTm1:

• constants: SqrTm1

start:

• multistream: start(m: MultistreamSelect): InternalRaisesFuture[void, (CancelledError,)]
• relay: start(r: Relay): InternalRaisesFuture[void, (CancelledError,)]
• rtransport: start(self: RelayTransport; ma: seq[MultiAddress]): Future[void]
• protocol: start(p: LPProtocol): InternalRaisesFuture[void, (CancelledError,)]
• gossipsub: start(g: GossipSub): InternalRaisesFuture[void, (CancelledError,)]
• rendezvous: start(rdv: RendezVous): InternalRaisesFuture[void, (CancelledError,)]
• switch: start(s: Switch): Future[void]
• tcptransport: start(self: TcpTransport; addrs: seq[MultiAddress]): Future[void]
• transport: start(self: Transport; addrs: seq[MultiAddress]): Future[void]
• wstransport: start(self: WsTransport; addrs: seq[MultiAddress]): Future[void]

StartGroup:

• ProtoFieldKind.StartGroup

StatusV1:

• messages: StatusV1

StatusV2:

• messages: StatusV2

stop:

• multistream: stop(m: MultistreamSelect): InternalRaisesFuture[void, void]
• relay: stop(r: Relay): InternalRaisesFuture[void, void]
• rtransport: stop(self: RelayTransport): Future[void]
• protocol: stop(p: LPProtocol): InternalRaisesFuture[void, void]
• gossipsub: stop(g: GossipSub): InternalRaisesFuture[void, void]
• rendezvous: stop(rdv: RendezVous): InternalRaisesFuture[void, void]
• switch: stop(s: Switch): Future[void]
• switch: stop(self: Service; switch: Switch): Future[bool]
• tcptransport: stop(self: TcpTransport): Future[void]
• transport: stop(self: Transport): Future[void]
• wstransport: stop(self: WsTransport): Future[void]

StopMessage:

• messages: StopMessage

StopMessageType:

• messages: StopMessageType

stopSendNonPriorityTask:

• pubsubpeer: stopSendNonPriorityTask(p: PubSubPeer)

StreamHandler:

• muxer: StreamHandler

StreamSeq:

• streamseq: StreamSeq

StreamTracker:

• lpstream: StreamTracker

stretchKeys:

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

SubOpts:

• messages: SubOpts

subscribe:

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

subscribePeer:

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

SubscriptionValidator:

• pubsub: SubscriptionValidator

supported:

• crypto: supported(scheme: PKScheme): bool

SupportedSchemes:

• crypto: SupportedSchemes

SupportedSchemesInt:

• crypto: SupportedSchemesInt

SupportedWireTypes:

• minprotobuf: SupportedWireTypes

Switch:

• switch: Switch

SwitchBuilder:

• builders: SwitchBuilder

TCP:

• multiaddress: TCP

TCP_DNS:

• multiaddress: TCP_DNS

TCP_IP:

• multiaddress: TCP_IP

TcpOnion3:

• multiaddress: TcpOnion3

tcpProtocol:

• IpTransportProtocol.tcpProtocol

TcpTransport:

• tcptransport: TcpTransport

TcpTransportError:

• tcptransport: TcpTransportError

TcpTransportTrackerName:

• tcptransport: TcpTransportTrackerName

TimedCache:

• timedcache: TimedCache

TimedEntry:

• timedcache: TimedEntry

Timeout:

• timedcache: Timeout

TimeoutHandler:

• connection: TimeoutHandler

TLS_WS:

• multiaddress: TLS_WS

toBytes:

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

toException:

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

TooManyChannels:

• muxer: TooManyChannels

TooManyConnectionsError:

• connmanager: TooManyConnectionsError

toOpenArray:

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

toOpt:

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

TopicHandler:

• pubsub: TopicHandler

TopicInfo:

• types: TopicInfo

TopicPair:

• pubsub: TopicPair

TopicParams:

• types: TopicParams

toRawBytes:

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

toSecret:

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

toString:

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

trackConnection:

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

trackMuxer:

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

Transcoder:

• transcoder: Transcoder

TranscoderDNS:

• multiaddress: TranscoderDNS

TranscoderIP4:

• multiaddress: TranscoderIP4

TranscoderIP6:

• multiaddress: TranscoderIP6

TranscoderIP6Zone:

• multiaddress: TranscoderIP6Zone

TranscoderOnion:

• multiaddress: TranscoderOnion

TranscoderOnion3:

• multiaddress: TranscoderOnion3

TranscoderP2P:

• multiaddress: TranscoderP2P

TranscoderPort:

• multiaddress: TranscoderPort

TranscoderUnix:

• multiaddress: TranscoderUnix

TRANSPMA:

• wire: TRANSPMA

Transport:

• transport: Transport

TransportClosedError:

• transport: TransportClosedError

TransportError:

• transport: TransportError

TransportInvalidAddrError:

• transport: TransportInvalidAddrError

TransportProvider:

• builders: TransportProvider

triggerPeerEvents:

• connmanager: triggerPeerEvents(c: ConnManager; peerId: PeerId; event: PeerEvent): Future[void]

tryAcquire:

• semaphore: tryAcquire(s: AsyncSemaphore): bool

tryDial:

• dial: tryDial(self: Dial; peerId: PeerId; addrs: seq[MultiAddress]): Future[ Opt[MultiAddress]]
• dialer: tryDial(self: Dialer; peerId: PeerId; addrs: seq[MultiAddress]): Future[ Opt[MultiAddress]]

UDP:

• multiaddress: UDP

UDP_DNS:

• multiaddress: UDP_DNS

UDP_IP:

• multiaddress: UDP_IP

udpProtocol:

• IpTransportProtocol.udpProtocol

UnexpectedMessage:

• StatusV2.UnexpectedMessage

UNIX:

• multiaddress: UNIX

Unreliable:

• multiaddress: Unreliable

unsubscribe:

• pubsub: unsubscribe(p: PubSub; topics: openArray[TopicPair])
• pubsub: unsubscribe(p: PubSub; topic: string; handler: TopicHandler)
• rendezvous: unsubscribe(rdv: RendezVous; ns: string): Future[void]

unsubscribeAll:

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

unsubscribeLocally:

• rendezvous: unsubscribeLocally(rdv: RendezVous; ns: string)

unsubscribePeer:

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

update:

• peerinfo: update(p: PeerInfo): Future[void]

updateMetrics:

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

updateScores:

• scoring: updateScores(g: GossipSub)

upgrade:

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

Upgrade:

• upgrade: Upgrade

upgrade:

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

UpgradeFailedError:

• upgrade: UpgradeFailedError

UTP:

• multiaddress: UTP

validate:

• multiaddress: validate(ma: MultiAddress): bool
• multihash: validate(mhtype: typedesc[MultiHash]; data: openArray[byte]): bool
• peerid: validate(pid: PeerId): bool
• pubsub: validate(p: PubSub; message: Message): Future[ValidationResult]

validateParameters:

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

ValidationResult:

• errors: ValidationResult

ValidationSeenTable:

• types: ValidationSeenTable

ValidatorHandler:

• pubsub: ValidatorHandler

valueOr:

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

Varint:

• ProtoFieldKind.Varint

VarintError:

• varint: VarintError

VarintResult:

• varint: VarintResult

VBuffer:

• vbuffer: VBuffer

verify:

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

Voucher:

• messages: Voucher

vsizeof:

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

WebRTCDirect:

• multiaddress: WebRTCDirect

WebSockets:

• multiaddress: WebSockets

WebSockets_DNS:

• multiaddress: WebSockets_DNS

WebSockets_IP:

• multiaddress: WebSockets_IP

window:

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

withAddress:

• builders: withAddress(b: SwitchBuilder; address: MultiAddress): SwitchBuilder

withAddresses:

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

withAgentVersion:

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

withAutonat:

• builders: withAutonat(b: SwitchBuilder): SwitchBuilder

withCircuitRelay:

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

withMaxConnections:

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

withMaxConnsPerPeer:

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

withMaxIn:

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

withMaxOut:

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

withNameResolver:

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

withNoise:

• builders: withNoise(b: SwitchBuilder): SwitchBuilder

withObservedAddrManager:

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

withPeerStats:

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

withPeerStore:

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

withPrivateKey:

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

withProtoVersion:

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

withRendezVous:

• builders: withRendezVous(b: SwitchBuilder; rdv: RendezVous = RendezVous.new()): SwitchBuilder

withRng:

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

withServices:

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

withSignedPeerRecord:

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

withSubs:

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

withTcpTransport:

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

withTransport:

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

WithUint32BeLength:

• ProtoFlags.WithUint32BeLength

WithUint32LeLength:

• ProtoFlags.WithUint32LeLength

withValue:

• utility: withValue[T](self: Opt[T] | Option[T]; value, body, elseStmt: untyped): untyped
• utility: withValue[T](self: Opt[T] | Option[T]; value, body: untyped): untyped

WithVarintLength:

• ProtoFlags.WithVarintLength

write:

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

writeArray:

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

writeLp:

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

writeLPVarint:

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

writeMsg:

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

writePacked:

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

writePBVarint:

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

writeSeq:

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

writeVarint:

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

WrongPingAckError:

• ping: WrongPingAckError

WS:

• multiaddress: WS

WS_DNS:

• multiaddress: WS_DNS

WS_IP:

• multiaddress: WS_IP

WSS:

• multiaddress: WSS

WSS_DNS:

• multiaddress: WSS_DNS

WSS_IP:

• multiaddress: WSS_IP

WsTransport:

• wstransport: WsTransport

Yamux:

• yamux: Yamux

YamuxChannel:

• yamux: YamuxChannel

YamuxCodec:

• yamux: YamuxCodec

YamuxDefaultWindowSize:

• yamux: YamuxDefaultWindowSize

YamuxError:

• yamux: YamuxError

ZeroFe:

• constants: ZeroFe

zint:

• varint: zint

zint32:

• varint: zint32

zint64:

• varint: zint64