vacp2p
/
nim-libp2p
mirror of https://github.com/vacp2p/nim-libp2p.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Less warnings (#813) 

Co-authored-by: Diego <diego@status.im>
This commit is contained in:
Tanguy 2023-05-18 10:24:17 +02:00 committed by GitHub
parent 7d6bc545e0
commit 225accd11b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
94 changed files with 918 additions and 587 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
.pinned
View File

@ -1,16 +1,16 @@
bearssl;https://github.com/status-im/nim-bearssl@#acf9645e328bdcab481cfda1c158e07ecd46bd7b bearssl;https://github.com/status-im/nim-bearssl@#acf9645e328bdcab481cfda1c158e07ecd46bd7b
chronicles;https://github.com/status-im/nim-chronicles@#32ac8679680ea699f7dbc046e8e0131cac97d41a chronicles;https://github.com/status-im/nim-chronicles@#1e6350870855541b381d77d4659688bc0d2c4227
chronos;https://github.com/status-im/nim-chronos@#ab5a8c2e0f6941fe3debd61dff0293790079d1b0 chronos;https://github.com/status-im/nim-chronos@#ab5a8c2e0f6941fe3debd61dff0293790079d1b0
dnsclient;https://github.com/ba0f3/dnsclient.nim@#fcd7443634b950eaea574e5eaa00a628ae029823 dnsclient;https://github.com/ba0f3/dnsclient.nim@#fcd7443634b950eaea574e5eaa00a628ae029823
faststreams;https://github.com/status-im/nim-faststreams@#814f8927e1f356f39219f37f069b83066bcc893a faststreams;https://github.com/status-im/nim-faststreams@#814f8927e1f356f39219f37f069b83066bcc893a
httputils;https://github.com/status-im/nim-http-utils@#a85bd52ae0a956983ca6b3267c72961d2ec0245f httputils;https://github.com/status-im/nim-http-utils@#a85bd52ae0a956983ca6b3267c72961d2ec0245f
json_serialization;https://github.com/status-im/nim-json-serialization@#a7d815ed92f200f490c95d3cfd722089cc923ce6 json_serialization;https://github.com/status-im/nim-json-serialization@#a7d815ed92f200f490c95d3cfd722089cc923ce6
metrics;https://github.com/status-im/nim-metrics@#21e99a2e9d9f80e68bef65c80ef781613005fccb metrics;https://github.com/status-im/nim-metrics@#abf3acc7f06cee9ee2c287d2f31413dc3df4c04e
nimcrypto;https://github.com/cheatfate/nimcrypto@#4014ef939b51e02053c2e16dd3481d47bc9267dd nimcrypto;https://github.com/cheatfate/nimcrypto@#4014ef939b51e02053c2e16dd3481d47bc9267dd
secp256k1;https://github.com/status-im/nim-secp256k1@#fd173fdff863ce2e211cf64c9a03bc7539fe40b0 secp256k1;https://github.com/status-im/nim-secp256k1@#fd173fdff863ce2e211cf64c9a03bc7539fe40b0
serialization;https://github.com/status-im/nim-serialization@#5b7cea55efeb074daa8abd8146a03a34adb4521a serialization;https://github.com/status-im/nim-serialization@#5b7cea55efeb074daa8abd8146a03a34adb4521a
stew;https://github.com/status-im/nim-stew@#407a59883691d362db2fe8eab7f7c3b1f75112ff stew;https://github.com/status-im/nim-stew@#8caa9771995b266e10b2e7c0de6cbfa698902e68
testutils;https://github.com/status-im/nim-testutils@#dfc4c1b39f9ded9baf6365014de2b4bfb4dafc34 testutils;https://github.com/status-im/nim-testutils@#dfc4c1b39f9ded9baf6365014de2b4bfb4dafc34
unittest2;https://github.com/status-im/nim-unittest2@#da8398c45cafd5bd7772da1fc96e3924a18d3823 unittest2;https://github.com/status-im/nim-unittest2@#883c7a50ad3b82158e64d074c5578fe33ab3c452
websock;https://github.com/status-im/nim-websock@#fea05cde8b123b38d1a0a8524b77efbc84daa848 websock;https://github.com/status-im/nim-websock@#fea05cde8b123b38d1a0a8524b77efbc84daa848
zlib;https://github.com/status-im/nim-zlib@#826e2fc013f55b4478802d4f2e39f187c50d520a zlib;https://github.com/status-im/nim-zlib@#826e2fc013f55b4478802d4f2e39f187c50d520a

3
libp2p.nim
View File

@ -48,12 +48,9 @@ else:
stream/connection, stream/connection,
transports/transport, transports/transport,
transports/tcptransport, transports/tcptransport,
transports/wstransport,
protocols/secure/noise, protocols/secure/noise,
protocols/ping,
cid, cid,
multihash, multihash,
multibase,
multicodec, multicodec,
errors, errors,
switch, switch,

3
libp2p/builders.nim
View File

@ -298,9 +298,10 @@ proc newStandardSwitch*(
peerStoreCapacity = 1000): Switch peerStoreCapacity = 1000): Switch
{.raises: [Defect, LPError], public.} = {.raises: [Defect, LPError], public.} =
## Helper for common switch configurations. ## Helper for common switch configurations.
{.push warning[Deprecated]:off.}
if SecureProtocol.Secio in secureManagers: if SecureProtocol.Secio in secureManagers:
quit("Secio is deprecated!") # use of secio is unsafe quit("Secio is deprecated!") # use of secio is unsafe
{.pop.}
let addrs = when addrs is MultiAddress: @[addrs] else: addrs let addrs = when addrs is MultiAddress: @[addrs] else: addrs
var b = SwitchBuilder var b = SwitchBuilder

37
libp2p/connmanager.nim
View File

@ -121,28 +121,13 @@ proc addConnEventHandler*(c: ConnManager,
kind: ConnEventKind) = kind: ConnEventKind) =
## Add peer event handler - handlers must not raise exceptions! ## Add peer event handler - handlers must not raise exceptions!
## ##
if isNil(handler): return
try: c.connEvents[kind].incl(handler)
if isNil(handler): return
c.connEvents[kind].incl(handler)
except Exception as exc:
# TODO: there is an Exception being raised
# somewhere in the depths of the std.
# Might be related to https://github.com/nim-lang/Nim/issues/17382
raiseAssert exc.msg
proc removeConnEventHandler*(c: ConnManager, proc removeConnEventHandler*(c: ConnManager,
handler: ConnEventHandler, handler: ConnEventHandler,
kind: ConnEventKind) = kind: ConnEventKind) =
try:
c.connEvents[kind].excl(handler) c.connEvents[kind].excl(handler)
except Exception as exc:
# TODO: there is an Exception being raised
# somewhere in the depths of the std.
# Might be related to https://github.com/nim-lang/Nim/issues/17382
raiseAssert exc.msg
proc triggerConnEvent*(c: ConnManager, proc triggerConnEvent*(c: ConnManager,
peerId: PeerId, peerId: PeerId,
@ -169,26 +154,12 @@ proc addPeerEventHandler*(c: ConnManager,
## ##
if isNil(handler): return if isNil(handler): return
try: c.peerEvents[kind].incl(handler)
c.peerEvents[kind].incl(handler)
except Exception as exc:
# TODO: there is an Exception being raised
# somewhere in the depths of the std.
# Might be related to https://github.com/nim-lang/Nim/issues/17382
raiseAssert exc.msg
proc removePeerEventHandler*(c: ConnManager, proc removePeerEventHandler*(c: ConnManager,
handler: PeerEventHandler, handler: PeerEventHandler,
kind: PeerEventKind) = kind: PeerEventKind) =
try: c.peerEvents[kind].excl(handler)
c.peerEvents[kind].excl(handler)
except Exception as exc:
# TODO: there is an Exception being raised
# somewhere in the depths of the std.
# Might be related to https://github.com/nim-lang/Nim/issues/17382
raiseAssert exc.msg
proc triggerPeerEvents*(c: ConnManager, proc triggerPeerEvents*(c: ConnManager,
peerId: PeerId, peerId: PeerId,

2
libp2p/crypto/chacha20poly1305.nim
View File

@ -22,7 +22,7 @@ else:
import bearssl/blockx import bearssl/blockx
from stew/assign2 import assign from stew/assign2 import assign
from stew/ranges/ptr_arith import baseAddr from stew/ptrops import baseAddr
const const
ChaChaPolyKeySize = 32 ChaChaPolyKeySize = 32

2
libp2p/crypto/curve25519.nim
View File

@ -20,7 +20,7 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import bearssl/[ec, rand, hash] import bearssl/[ec, rand]
import stew/results import stew/results
from stew/assign2 import assign from stew/assign2 import assign
export results export results

31
libp2p/crypto/ecnist.nim
View File

@ -25,6 +25,9 @@ import nimcrypto/utils as ncrutils
import minasn1 import minasn1
export minasn1.Asn1Error export minasn1.Asn1Error
import stew/[results, ctops] import stew/[results, ctops]
import ../utility
export results export results
const const
@ -74,7 +77,7 @@ type
EcResult*[T] = Result[T, EcError] EcResult*[T] = Result[T, EcError]
const const
EcSupportedCurvesCint* = {cint(Secp256r1), cint(Secp384r1), cint(Secp521r1)} EcSupportedCurvesCint* = @[cint(Secp256r1), cint(Secp384r1), cint(Secp521r1)]
proc `-`(x: uint32): uint32 {.inline.} = proc `-`(x: uint32): uint32 {.inline.} =
result = (0xFFFF_FFFF'u32 - x) + 1'u32 result = (0xFFFF_FFFF'u32 - x) + 1'u32
@ -243,7 +246,7 @@ proc random*(
var res = new EcPrivateKey var res = new EcPrivateKey
if ecKeygen(addr rng.vtable, ecimp, if ecKeygen(addr rng.vtable, ecimp,
addr res.key, addr res.buffer[0], addr res.key, addr res.buffer[0],
cast[cint](kind)) == 0: safeConvert[cint](kind)) == 0:
err(EcKeyGenError) err(EcKeyGenError)
else: else:
ok(res) ok(res)
@ -630,11 +633,11 @@ proc init*(key: var EcPrivateKey, data: openArray[byte]): Result[void, Asn1Error
return err(Asn1Error.Incorrect) return err(Asn1Error.Incorrect)
if oid == Asn1OidSecp256r1: if oid == Asn1OidSecp256r1:
curve = cast[cint](Secp256r1) curve = safeConvert[cint](Secp256r1)
elif oid == Asn1OidSecp384r1: elif oid == Asn1OidSecp384r1:
curve = cast[cint](Secp384r1) curve = safeConvert[cint](Secp384r1)
elif oid == Asn1OidSecp521r1: elif oid == Asn1OidSecp521r1:
curve = cast[cint](Secp521r1) curve = safeConvert[cint](Secp521r1)
else: else:
return err(Asn1Error.Incorrect) return err(Asn1Error.Incorrect)
@ -684,11 +687,11 @@ proc init*(pubkey: var EcPublicKey, data: openArray[byte]): Result[void, Asn1Err
return err(Asn1Error.Incorrect) return err(Asn1Error.Incorrect)
if oid == Asn1OidSecp256r1: if oid == Asn1OidSecp256r1:
curve = cast[cint](Secp256r1) curve = safeConvert[cint](Secp256r1)
elif oid == Asn1OidSecp384r1: elif oid == Asn1OidSecp384r1:
curve = cast[cint](Secp384r1) curve = safeConvert[cint](Secp384r1)
elif oid == Asn1OidSecp521r1: elif oid == Asn1OidSecp521r1:
curve = cast[cint](Secp521r1) curve = safeConvert[cint](Secp521r1)
else: else:
return err(Asn1Error.Incorrect) return err(Asn1Error.Incorrect)
@ -774,13 +777,13 @@ proc initRaw*(key: var EcPrivateKey, data: openArray[byte]): bool =
## Procedure returns ``true`` on success, ``false`` otherwise. ## Procedure returns ``true`` on success, ``false`` otherwise.
var curve: cint var curve: cint
if len(data) == SecKey256Length: if len(data) == SecKey256Length:
curve = cast[cint](Secp256r1) curve = safeConvert[cint](Secp256r1)
result = true result = true
elif len(data) == SecKey384Length: elif len(data) == SecKey384Length:
curve = cast[cint](Secp384r1) curve = safeConvert[cint](Secp384r1)
result = true result = true
elif len(data) == SecKey521Length: elif len(data) == SecKey521Length:
curve = cast[cint](Secp521r1) curve = safeConvert[cint](Secp521r1)
result = true result = true
if result: if result:
result = false result = false
@ -805,13 +808,13 @@ proc initRaw*(pubkey: var EcPublicKey, data: openArray[byte]): bool =
if len(data) > 0: if len(data) > 0:
if data[0] == 0x04'u8: if data[0] == 0x04'u8:
if len(data) == PubKey256Length: if len(data) == PubKey256Length:
curve = cast[cint](Secp256r1) curve = safeConvert[cint](Secp256r1)
result = true result = true
elif len(data) == PubKey384Length: elif len(data) == PubKey384Length:
curve = cast[cint](Secp384r1) curve = safeConvert[cint](Secp384r1)
result = true result = true
elif len(data) == PubKey521Length: elif len(data) == PubKey521Length:
curve = cast[cint](Secp521r1) curve = safeConvert[cint](Secp521r1)
result = true result = true
if result: if result:
result = false result = false

447
libp2p/crypto/ed25519/ed25519.nim
View File

@ -22,6 +22,9 @@ import nimcrypto/[hash, sha2]
# We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures. # We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures.
import nimcrypto/utils as ncrutils import nimcrypto/utils as ncrutils
import stew/[results, ctops] import stew/[results, ctops]
import ../../utility
export results export results
# This workaround needed because of some bugs in Nim Static[T]. # This workaround needed because of some bugs in Nim Static[T].
@ -170,15 +173,15 @@ proc feCopy(h: var Fe, f: Fe) =
h[9] = f9 h[9] = f9
proc load_3(inp: openArray[byte]): uint64 = proc load_3(inp: openArray[byte]): uint64 =
result = cast[uint64](inp[0]) result = safeConvert[uint64](inp[0])
result = result or (cast[uint64](inp[1]) shl 8) result = result or (safeConvert[uint64](inp[1]) shl 8)
result = result or (cast[uint64](inp[2]) shl 16) result = result or (safeConvert[uint64](inp[2]) shl 16)
proc load_4(inp: openArray[byte]): uint64 = proc load_4(inp: openArray[byte]): uint64 =
result = cast[uint64](inp[0]) result = safeConvert[uint64](inp[0])
result = result or (cast[uint64](inp[1]) shl 8) result = result or (safeConvert[uint64](inp[1]) shl 8)
result = result or (cast[uint64](inp[2]) shl 16) result = result or (safeConvert[uint64](inp[2]) shl 16)
result = result or (cast[uint64](inp[3]) shl 24) result = result or (safeConvert[uint64](inp[3]) shl 24)
proc feFromBytes(h: var Fe, s: openArray[byte]) = proc feFromBytes(h: var Fe, s: openArray[byte]) =
var c0, c1, c2, c3, c4, c5, c6, c7, c8, c9: int64 var c0, c1, c2, c3, c4, c5, c6, c7, c8, c9: int64
@ -299,106 +302,106 @@ proc feMul(h: var Fe, f, g: Fe) =
var f5_2 = 2 * f5 var f5_2 = 2 * f5
var f7_2 = 2 * f7 var f7_2 = 2 * f7
var f9_2 = 2 * f9 var f9_2 = 2 * f9
var f0g0 = cast[int64](f0) * cast[int64](g0) var f0g0 = safeConvert[int64](f0) * safeConvert[int64](g0)
var f0g1 = cast[int64](f0) * cast[int64](g1) var f0g1 = safeConvert[int64](f0) * safeConvert[int64](g1)
var f0g2 = cast[int64](f0) * cast[int64](g2) var f0g2 = safeConvert[int64](f0) * safeConvert[int64](g2)
var f0g3 = cast[int64](f0) * cast[int64](g3) var f0g3 = safeConvert[int64](f0) * safeConvert[int64](g3)
var f0g4 = cast[int64](f0) * cast[int64](g4) var f0g4 = safeConvert[int64](f0) * safeConvert[int64](g4)
var f0g5 = cast[int64](f0) * cast[int64](g5) var f0g5 = safeConvert[int64](f0) * safeConvert[int64](g5)
var f0g6 = cast[int64](f0) * cast[int64](g6) var f0g6 = safeConvert[int64](f0) * safeConvert[int64](g6)
var f0g7 = cast[int64](f0) * cast[int64](g7) var f0g7 = safeConvert[int64](f0) * safeConvert[int64](g7)
var f0g8 = cast[int64](f0) * cast[int64](g8) var f0g8 = safeConvert[int64](f0) * safeConvert[int64](g8)
var f0g9 = cast[int64](f0) * cast[int64](g9) var f0g9 = safeConvert[int64](f0) * safeConvert[int64](g9)
var f1g0 = cast[int64](f1) * cast[int64](g0) var f1g0 = safeConvert[int64](f1) * safeConvert[int64](g0)
var f1g1_2 = cast[int64](f1_2) * cast[int64](g1) var f1g1_2 = safeConvert[int64](f1_2) * safeConvert[int64](g1)
var f1g2 = cast[int64](f1) * cast[int64](g2) var f1g2 = safeConvert[int64](f1) * safeConvert[int64](g2)
var f1g3_2 = cast[int64](f1_2) * cast[int64](g3) var f1g3_2 = safeConvert[int64](f1_2) * safeConvert[int64](g3)
var f1g4 = cast[int64](f1) * cast[int64](g4) var f1g4 = safeConvert[int64](f1) * safeConvert[int64](g4)
var f1g5_2 = cast[int64](f1_2) * cast[int64](g5) var f1g5_2 = safeConvert[int64](f1_2) * safeConvert[int64](g5)
var f1g6 = cast[int64](f1) * cast[int64](g6) var f1g6 = safeConvert[int64](f1) * safeConvert[int64](g6)
var f1g7_2 = cast[int64](f1_2) * cast[int64](g7) var f1g7_2 = safeConvert[int64](f1_2) * safeConvert[int64](g7)
var f1g8 = cast[int64](f1) * cast[int64](g8) var f1g8 = safeConvert[int64](f1) * safeConvert[int64](g8)
var f1g9_38 = cast[int64](f1_2) * cast[int64](g9_19) var f1g9_38 = safeConvert[int64](f1_2) * safeConvert[int64](g9_19)
var f2g0 = cast[int64](f2) * cast[int64](g0) var f2g0 = safeConvert[int64](f2) * safeConvert[int64](g0)
var f2g1 = cast[int64](f2) * cast[int64](g1) var f2g1 = safeConvert[int64](f2) * safeConvert[int64](g1)
var f2g2 = cast[int64](f2) * cast[int64](g2) var f2g2 = safeConvert[int64](f2) * safeConvert[int64](g2)
var f2g3 = cast[int64](f2) * cast[int64](g3) var f2g3 = safeConvert[int64](f2) * safeConvert[int64](g3)
var f2g4 = cast[int64](f2) * cast[int64](g4) var f2g4 = safeConvert[int64](f2) * safeConvert[int64](g4)
var f2g5 = cast[int64](f2) * cast[int64](g5) var f2g5 = safeConvert[int64](f2) * safeConvert[int64](g5)
var f2g6 = cast[int64](f2) * cast[int64](g6) var f2g6 = safeConvert[int64](f2) * safeConvert[int64](g6)
var f2g7 = cast[int64](f2) * cast[int64](g7) var f2g7 = safeConvert[int64](f2) * safeConvert[int64](g7)
var f2g8_19 = cast[int64](f2) * cast[int64](g8_19) var f2g8_19 = safeConvert[int64](f2) * safeConvert[int64](g8_19)
var f2g9_19 = cast[int64](f2) * cast[int64](g9_19) var f2g9_19 = safeConvert[int64](f2) * safeConvert[int64](g9_19)
var f3g0 = cast[int64](f3) * cast[int64](g0) var f3g0 = safeConvert[int64](f3) * safeConvert[int64](g0)
var f3g1_2 = cast[int64](f3_2) * cast[int64](g1) var f3g1_2 = safeConvert[int64](f3_2) * safeConvert[int64](g1)
var f3g2 = cast[int64](f3) * cast[int64](g2) var f3g2 = safeConvert[int64](f3) * safeConvert[int64](g2)
var f3g3_2 = cast[int64](f3_2) * cast[int64](g3) var f3g3_2 = safeConvert[int64](f3_2) * safeConvert[int64](g3)
var f3g4 = cast[int64](f3) * cast[int64](g4) var f3g4 = safeConvert[int64](f3) * safeConvert[int64](g4)
var f3g5_2 = cast[int64](f3_2) * cast[int64](g5) var f3g5_2 = safeConvert[int64](f3_2) * safeConvert[int64](g5)
var f3g6 = cast[int64](f3) * cast[int64](g6) var f3g6 = safeConvert[int64](f3) * safeConvert[int64](g6)
var f3g7_38 = cast[int64](f3_2) * cast[int64](g7_19) var f3g7_38 = safeConvert[int64](f3_2) * safeConvert[int64](g7_19)
var f3g8_19 = cast[int64](f3) * cast[int64](g8_19) var f3g8_19 = safeConvert[int64](f3) * safeConvert[int64](g8_19)
var f3g9_38 = cast[int64](f3_2) * cast[int64](g9_19) var f3g9_38 = safeConvert[int64](f3_2) * safeConvert[int64](g9_19)
var f4g0 = cast[int64](f4) * cast[int64](g0) var f4g0 = safeConvert[int64](f4) * safeConvert[int64](g0)
var f4g1 = cast[int64](f4) * cast[int64](g1) var f4g1 = safeConvert[int64](f4) * safeConvert[int64](g1)
var f4g2 = cast[int64](f4) * cast[int64](g2) var f4g2 = safeConvert[int64](f4) * safeConvert[int64](g2)
var f4g3 = cast[int64](f4) * cast[int64](g3) var f4g3 = safeConvert[int64](f4) * safeConvert[int64](g3)
var f4g4 = cast[int64](f4) * cast[int64](g4) var f4g4 = safeConvert[int64](f4) * safeConvert[int64](g4)
var f4g5 = cast[int64](f4) * cast[int64](g5) var f4g5 = safeConvert[int64](f4) * safeConvert[int64](g5)
var f4g6_19 = cast[int64](f4) * cast[int64](g6_19) var f4g6_19 = safeConvert[int64](f4) * safeConvert[int64](g6_19)
var f4g7_19 = cast[int64](f4) * cast[int64](g7_19) var f4g7_19 = safeConvert[int64](f4) * safeConvert[int64](g7_19)
var f4g8_19 = cast[int64](f4) * cast[int64](g8_19) var f4g8_19 = safeConvert[int64](f4) * safeConvert[int64](g8_19)
var f4g9_19 = cast[int64](f4) * cast[int64](g9_19) var f4g9_19 = safeConvert[int64](f4) * safeConvert[int64](g9_19)
var f5g0 = cast[int64](f5) * cast[int64](g0) var f5g0 = safeConvert[int64](f5) * safeConvert[int64](g0)
var f5g1_2 = cast[int64](f5_2) * cast[int64](g1) var f5g1_2 = safeConvert[int64](f5_2) * safeConvert[int64](g1)
var f5g2 = cast[int64](f5) * cast[int64](g2) var f5g2 = safeConvert[int64](f5) * safeConvert[int64](g2)
var f5g3_2 = cast[int64](f5_2) * cast[int64](g3) var f5g3_2 = safeConvert[int64](f5_2) * safeConvert[int64](g3)
var f5g4 = cast[int64](f5) * cast[int64](g4) var f5g4 = safeConvert[int64](f5) * safeConvert[int64](g4)
var f5g5_38 = cast[int64](f5_2) * cast[int64](g5_19) var f5g5_38 = safeConvert[int64](f5_2) * safeConvert[int64](g5_19)
var f5g6_19 = cast[int64](f5) * cast[int64](g6_19) var f5g6_19 = safeConvert[int64](f5) * safeConvert[int64](g6_19)
var f5g7_38 = cast[int64](f5_2) * cast[int64](g7_19) var f5g7_38 = safeConvert[int64](f5_2) * safeConvert[int64](g7_19)
var f5g8_19 = cast[int64](f5) * cast[int64](g8_19) var f5g8_19 = safeConvert[int64](f5) * safeConvert[int64](g8_19)
var f5g9_38 = cast[int64](f5_2) * cast[int64](g9_19) var f5g9_38 = safeConvert[int64](f5_2) * safeConvert[int64](g9_19)
var f6g0 = cast[int64](f6) * cast[int64](g0) var f6g0 = safeConvert[int64](f6) * safeConvert[int64](g0)
var f6g1 = cast[int64](f6) * cast[int64](g1) var f6g1 = safeConvert[int64](f6) * safeConvert[int64](g1)
var f6g2 = cast[int64](f6) * cast[int64](g2) var f6g2 = safeConvert[int64](f6) * safeConvert[int64](g2)
var f6g3 = cast[int64](f6) * cast[int64](g3) var f6g3 = safeConvert[int64](f6) * safeConvert[int64](g3)
var f6g4_19 = cast[int64](f6) * cast[int64](g4_19) var f6g4_19 = safeConvert[int64](f6) * safeConvert[int64](g4_19)
var f6g5_19 = cast[int64](f6) * cast[int64](g5_19) var f6g5_19 = safeConvert[int64](f6) * safeConvert[int64](g5_19)
var f6g6_19 = cast[int64](f6) * cast[int64](g6_19) var f6g6_19 = safeConvert[int64](f6) * safeConvert[int64](g6_19)
var f6g7_19 = cast[int64](f6) * cast[int64](g7_19) var f6g7_19 = safeConvert[int64](f6) * safeConvert[int64](g7_19)
var f6g8_19 = cast[int64](f6) * cast[int64](g8_19) var f6g8_19 = safeConvert[int64](f6) * safeConvert[int64](g8_19)
var f6g9_19 = cast[int64](f6) * cast[int64](g9_19) var f6g9_19 = safeConvert[int64](f6) * safeConvert[int64](g9_19)
var f7g0 = cast[int64](f7) * cast[int64](g0) var f7g0 = safeConvert[int64](f7) * safeConvert[int64](g0)
var f7g1_2 = cast[int64](f7_2) * cast[int64](g1) var f7g1_2 = safeConvert[int64](f7_2) * safeConvert[int64](g1)
var f7g2 = cast[int64](f7) * cast[int64](g2) var f7g2 = safeConvert[int64](f7) * safeConvert[int64](g2)
var f7g3_38 = cast[int64](f7_2) * cast[int64](g3_19) var f7g3_38 = safeConvert[int64](f7_2) * safeConvert[int64](g3_19)
var f7g4_19 = cast[int64](f7) * cast[int64](g4_19) var f7g4_19 = safeConvert[int64](f7) * safeConvert[int64](g4_19)
var f7g5_38 = cast[int64](f7_2) * cast[int64](g5_19) var f7g5_38 = safeConvert[int64](f7_2) * safeConvert[int64](g5_19)
var f7g6_19 = cast[int64](f7) * cast[int64](g6_19) var f7g6_19 = safeConvert[int64](f7) * safeConvert[int64](g6_19)
var f7g7_38 = cast[int64](f7_2) * cast[int64](g7_19) var f7g7_38 = safeConvert[int64](f7_2) * safeConvert[int64](g7_19)
var f7g8_19 = cast[int64](f7) * cast[int64](g8_19) var f7g8_19 = safeConvert[int64](f7) * safeConvert[int64](g8_19)
var f7g9_38 = cast[int64](f7_2) * cast[int64](g9_19) var f7g9_38 = safeConvert[int64](f7_2) * safeConvert[int64](g9_19)
var f8g0 = cast[int64](f8) * cast[int64](g0) var f8g0 = safeConvert[int64](f8) * safeConvert[int64](g0)
var f8g1 = cast[int64](f8) * cast[int64](g1) var f8g1 = safeConvert[int64](f8) * safeConvert[int64](g1)
var f8g2_19 = cast[int64](f8) * cast[int64](g2_19) var f8g2_19 = safeConvert[int64](f8) * safeConvert[int64](g2_19)
var f8g3_19 = cast[int64](f8) * cast[int64](g3_19) var f8g3_19 = safeConvert[int64](f8) * safeConvert[int64](g3_19)
var f8g4_19 = cast[int64](f8) * cast[int64](g4_19) var f8g4_19 = safeConvert[int64](f8) * safeConvert[int64](g4_19)
var f8g5_19 = cast[int64](f8) * cast[int64](g5_19) var f8g5_19 = safeConvert[int64](f8) * safeConvert[int64](g5_19)
var f8g6_19 = cast[int64](f8) * cast[int64](g6_19) var f8g6_19 = safeConvert[int64](f8) * safeConvert[int64](g6_19)
var f8g7_19 = cast[int64](f8) * cast[int64](g7_19) var f8g7_19 = safeConvert[int64](f8) * safeConvert[int64](g7_19)
var f8g8_19 = cast[int64](f8) * cast[int64](g8_19) var f8g8_19 = safeConvert[int64](f8) * safeConvert[int64](g8_19)
var f8g9_19 = cast[int64](f8) * cast[int64](g9_19) var f8g9_19 = safeConvert[int64](f8) * safeConvert[int64](g9_19)
var f9g0 = cast[int64](f9) * cast[int64](g0) var f9g0 = safeConvert[int64](f9) * safeConvert[int64](g0)
var f9g1_38 = cast[int64](f9_2) * cast[int64](g1_19) var f9g1_38 = safeConvert[int64](f9_2) * safeConvert[int64](g1_19)
var f9g2_19 = cast[int64](f9) * cast[int64](g2_19) var f9g2_19 = safeConvert[int64](f9) * safeConvert[int64](g2_19)
var f9g3_38 = cast[int64](f9_2) * cast[int64](g3_19) var f9g3_38 = safeConvert[int64](f9_2) * safeConvert[int64](g3_19)
var f9g4_19 = cast[int64](f9) * cast[int64](g4_19) var f9g4_19 = safeConvert[int64](f9) * safeConvert[int64](g4_19)
var f9g5_38 = cast[int64](f9_2) * cast[int64](g5_19) var f9g5_38 = safeConvert[int64](f9_2) * safeConvert[int64](g5_19)
var f9g6_19 = cast[int64](f9) * cast[int64](g6_19) var f9g6_19 = safeConvert[int64](f9) * safeConvert[int64](g6_19)
var f9g7_38 = cast[int64](f9_2) * cast[int64](g7_19) var f9g7_38 = safeConvert[int64](f9_2) * safeConvert[int64](g7_19)
var f9g8_19 = cast[int64](f9) * cast[int64](g8_19) var f9g8_19 = safeConvert[int64](f9) * safeConvert[int64](g8_19)
var f9g9_38 = cast[int64](f9_2) * cast[int64](g9_19) var f9g9_38 = safeConvert[int64](f9_2) * safeConvert[int64](g9_19)
var var
c0, c1, c2, c3, c4, c5, c6, c7, c8, c9: int64 c0, c1, c2, c3, c4, c5, c6, c7, c8, c9: int64
h0: int64 = f0g0 + f1g9_38 + f2g8_19 + f3g7_38 + f4g6_19 + f5g5_38 + h0: int64 = f0g0 + f1g9_38 + f2g8_19 + f3g7_38 + f4g6_19 + f5g5_38 +
@ -493,7 +496,7 @@ proc verify32(x: openArray[byte], y: openArray[byte]): int32 =
proc feIsNegative(f: Fe): int32 = proc feIsNegative(f: Fe): int32 =
var s: array[32, byte] var s: array[32, byte]
feToBytes(s, f) feToBytes(s, f)
result = cast[int32](s[0] and 1'u8) result = safeConvert[int32](s[0] and 1'u8)
proc feIsNonZero(f: Fe): int32 = proc feIsNonZero(f: Fe): int32 =
var s: array[32, byte] var s: array[32, byte]
@ -516,61 +519,61 @@ proc feSq(h: var Fe, f: Fe) =
var f7_38: int32 = 38 * f7 var f7_38: int32 = 38 * f7
var f8_19: int32 = 19 * f8 var f8_19: int32 = 19 * f8
var f9_38: int32 = 38 * f9 var f9_38: int32 = 38 * f9
var f0f0: int64 = f0 * cast[int64](f0) var f0f0: int64 = f0 * safeConvert[int64](f0)
var f0f1_2: int64 = f0_2 * cast[int64](f1) var f0f1_2: int64 = f0_2 * safeConvert[int64](f1)
var f0f2_2: int64 = f0_2 * cast[int64](f2) var f0f2_2: int64 = f0_2 * safeConvert[int64](f2)
var f0f3_2: int64 = f0_2 * cast[int64](f3) var f0f3_2: int64 = f0_2 * safeConvert[int64](f3)
var f0f4_2: int64 = f0_2 * cast[int64](f4) var f0f4_2: int64 = f0_2 * safeConvert[int64](f4)
var f0f5_2: int64 = f0_2 * cast[int64](f5) var f0f5_2: int64 = f0_2 * safeConvert[int64](f5)
var f0f6_2: int64 = f0_2 * cast[int64](f6) var f0f6_2: int64 = f0_2 * safeConvert[int64](f6)
var f0f7_2: int64 = f0_2 * cast[int64](f7) var f0f7_2: int64 = f0_2 * safeConvert[int64](f7)
var f0f8_2: int64 = f0_2 * cast[int64](f8) var f0f8_2: int64 = f0_2 * safeConvert[int64](f8)
var f0f9_2: int64 = f0_2 * cast[int64](f9) var f0f9_2: int64 = f0_2 * safeConvert[int64](f9)
var f1f1_2: int64 = f1_2 * cast[int64](f1) var f1f1_2: int64 = f1_2 * safeConvert[int64](f1)
var f1f2_2: int64 = f1_2 * cast[int64](f2) var f1f2_2: int64 = f1_2 * safeConvert[int64](f2)
var f1f3_4: int64 = f1_2 * cast[int64](f3_2) var f1f3_4: int64 = f1_2 * safeConvert[int64](f3_2)
var f1f4_2: int64 = f1_2 * cast[int64](f4) var f1f4_2: int64 = f1_2 * safeConvert[int64](f4)
var f1f5_4: int64 = f1_2 * cast[int64](f5_2) var f1f5_4: int64 = f1_2 * safeConvert[int64](f5_2)
var f1f6_2: int64 = f1_2 * cast[int64](f6) var f1f6_2: int64 = f1_2 * safeConvert[int64](f6)
var f1f7_4: int64 = f1_2 * cast[int64](f7_2) var f1f7_4: int64 = f1_2 * safeConvert[int64](f7_2)
var f1f8_2: int64 = f1_2 * cast[int64](f8) var f1f8_2: int64 = f1_2 * safeConvert[int64](f8)
var f1f9_76: int64 = f1_2 * cast[int64](f9_38) var f1f9_76: int64 = f1_2 * safeConvert[int64](f9_38)
var f2f2: int64 = f2 * cast[int64](f2) var f2f2: int64 = f2 * safeConvert[int64](f2)
var f2f3_2: int64 = f2_2 * cast[int64](f3) var f2f3_2: int64 = f2_2 * safeConvert[int64](f3)
var f2f4_2: int64 = f2_2 * cast[int64](f4) var f2f4_2: int64 = f2_2 * safeConvert[int64](f4)
var f2f5_2: int64 = f2_2 * cast[int64](f5) var f2f5_2: int64 = f2_2 * safeConvert[int64](f5)
var f2f6_2: int64 = f2_2 * cast[int64](f6) var f2f6_2: int64 = f2_2 * safeConvert[int64](f6)
var f2f7_2: int64 = f2_2 * cast[int64](f7) var f2f7_2: int64 = f2_2 * safeConvert[int64](f7)
var f2f8_38: int64 = f2_2 * cast[int64](f8_19) var f2f8_38: int64 = f2_2 * safeConvert[int64](f8_19)
var f2f9_38: int64 = f2 * cast[int64](f9_38) var f2f9_38: int64 = f2 * safeConvert[int64](f9_38)
var f3f3_2: int64 = f3_2 * cast[int64](f3) var f3f3_2: int64 = f3_2 * safeConvert[int64](f3)
var f3f4_2: int64 = f3_2 * cast[int64](f4) var f3f4_2: int64 = f3_2 * safeConvert[int64](f4)
var f3f5_4: int64 = f3_2 * cast[int64](f5_2) var f3f5_4: int64 = f3_2 * safeConvert[int64](f5_2)
var f3f6_2: int64 = f3_2 * cast[int64](f6) var f3f6_2: int64 = f3_2 * safeConvert[int64](f6)
var f3f7_76: int64 = f3_2 * cast[int64](f7_38) var f3f7_76: int64 = f3_2 * safeConvert[int64](f7_38)
var f3f8_38: int64 = f3_2 * cast[int64](f8_19) var f3f8_38: int64 = f3_2 * safeConvert[int64](f8_19)
var f3f9_76: int64 = f3_2 * cast[int64](f9_38) var f3f9_76: int64 = f3_2 * safeConvert[int64](f9_38)
var f4f4: int64 = f4 * cast[int64](f4) var f4f4: int64 = f4 * safeConvert[int64](f4)
var f4f5_2: int64 = f4_2 * cast[int64](f5) var f4f5_2: int64 = f4_2 * safeConvert[int64](f5)
var f4f6_38: int64 = f4_2 * cast[int64](f6_19) var f4f6_38: int64 = f4_2 * safeConvert[int64](f6_19)
var f4f7_38: int64 = f4 * cast[int64](f7_38) var f4f7_38: int64 = f4 * safeConvert[int64](f7_38)
var f4f8_38: int64 = f4_2 * cast[int64](f8_19) var f4f8_38: int64 = f4_2 * safeConvert[int64](f8_19)
var f4f9_38: int64 = f4 * cast[int64](f9_38) var f4f9_38: int64 = f4 * safeConvert[int64](f9_38)
var f5f5_38: int64 = f5 * cast[int64](f5_38) var f5f5_38: int64 = f5 * safeConvert[int64](f5_38)
var f5f6_38: int64 = f5_2 * cast[int64](f6_19) var f5f6_38: int64 = f5_2 * safeConvert[int64](f6_19)
var f5f7_76: int64 = f5_2 * cast[int64](f7_38) var f5f7_76: int64 = f5_2 * safeConvert[int64](f7_38)
var f5f8_38: int64 = f5_2 * cast[int64](f8_19) var f5f8_38: int64 = f5_2 * safeConvert[int64](f8_19)
var f5f9_76: int64 = f5_2 * cast[int64](f9_38) var f5f9_76: int64 = f5_2 * safeConvert[int64](f9_38)
var f6f6_19: int64 = f6 * cast[int64](f6_19) var f6f6_19: int64 = f6 * safeConvert[int64](f6_19)
var f6f7_38: int64 = f6 * cast[int64](f7_38) var f6f7_38: int64 = f6 * safeConvert[int64](f7_38)
var f6f8_38: int64 = f6_2 * cast[int64](f8_19) var f6f8_38: int64 = f6_2 * safeConvert[int64](f8_19)
var f6f9_38: int64 = f6 * cast[int64](f9_38) var f6f9_38: int64 = f6 * safeConvert[int64](f9_38)
var f7f7_38: int64 = f7 * cast[int64](f7_38) var f7f7_38: int64 = f7 * safeConvert[int64](f7_38)
var f7f8_38: int64 = f7_2 * cast[int64](f8_19) var f7f8_38: int64 = f7_2 * safeConvert[int64](f8_19)
var f7f9_76: int64 = f7_2 * cast[int64](f9_38) var f7f9_76: int64 = f7_2 * safeConvert[int64](f9_38)
var f8f8_19: int64 = f8 * cast[int64](f8_19) var f8f8_19: int64 = f8 * safeConvert[int64](f8_19)
var f8f9_38: int64 = f8 * cast[int64](f9_38) var f8f9_38: int64 = f8 * safeConvert[int64](f9_38)
var f9f9_38: int64 = f9 * cast[int64](f9_38) var f9f9_38: int64 = f9 * safeConvert[int64](f9_38)
var h0: int64 = f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38 var h0: int64 = f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38
var h1: int64 = f0f1_2 + f2f9_38 + f3f8_38 + f4f7_38 + f5f6_38 var h1: int64 = f0f1_2 + f2f9_38 + f3f8_38 + f4f7_38 + f5f6_38
var h2: int64 = f0f2_2 + f1f1_2 + f3f9_76 + f4f8_38 + f5f7_76 + f6f6_19 var h2: int64 = f0f2_2 + f1f1_2 + f3f9_76 + f4f8_38 + f5f7_76 + f6f6_19
@ -623,61 +626,61 @@ proc feSq2(h: var Fe, f: Fe) =
var f7_38 = 38 * f7 var f7_38 = 38 * f7
var f8_19 = 19 * f8 var f8_19 = 19 * f8
var f9_38 = 38 * f9 var f9_38 = 38 * f9
var f0f0 = cast[int64](f0) * cast[int64](f0) var f0f0 = safeConvert[int64](f0) * safeConvert[int64](f0)
var f0f1_2 = cast[int64](f0_2) * cast[int64](f1) var f0f1_2 = safeConvert[int64](f0_2) * safeConvert[int64](f1)
var f0f2_2 = cast[int64](f0_2) * cast[int64](f2) var f0f2_2 = safeConvert[int64](f0_2) * safeConvert[int64](f2)
var f0f3_2 = cast[int64](f0_2) * cast[int64](f3) var f0f3_2 = safeConvert[int64](f0_2) * safeConvert[int64](f3)
var f0f4_2 = cast[int64](f0_2) * cast[int64](f4) var f0f4_2 = safeConvert[int64](f0_2) * safeConvert[int64](f4)
var f0f5_2 = cast[int64](f0_2) * cast[int64](f5) var f0f5_2 = safeConvert[int64](f0_2) * safeConvert[int64](f5)
var f0f6_2 = cast[int64](f0_2) * cast[int64](f6) var f0f6_2 = safeConvert[int64](f0_2) * safeConvert[int64](f6)
var f0f7_2 = cast[int64](f0_2) * cast[int64](f7) var f0f7_2 = safeConvert[int64](f0_2) * safeConvert[int64](f7)
var f0f8_2 = cast[int64](f0_2) * cast[int64](f8) var f0f8_2 = safeConvert[int64](f0_2) * safeConvert[int64](f8)
var f0f9_2 = cast[int64](f0_2) * cast[int64](f9) var f0f9_2 = safeConvert[int64](f0_2) * safeConvert[int64](f9)
var f1f1_2 = cast[int64](f1_2) * cast[int64](f1) var f1f1_2 = safeConvert[int64](f1_2) * safeConvert[int64](f1)
var f1f2_2 = cast[int64](f1_2) * cast[int64](f2) var f1f2_2 = safeConvert[int64](f1_2) * safeConvert[int64](f2)
var f1f3_4 = cast[int64](f1_2) * cast[int64](f3_2) var f1f3_4 = safeConvert[int64](f1_2) * safeConvert[int64](f3_2)
var f1f4_2 = cast[int64](f1_2) * cast[int64](f4) var f1f4_2 = safeConvert[int64](f1_2) * safeConvert[int64](f4)
var f1f5_4 = cast[int64](f1_2) * cast[int64](f5_2) var f1f5_4 = safeConvert[int64](f1_2) * safeConvert[int64](f5_2)
var f1f6_2 = cast[int64](f1_2) * cast[int64](f6) var f1f6_2 = safeConvert[int64](f1_2) * safeConvert[int64](f6)
var f1f7_4 = cast[int64](f1_2) * cast[int64](f7_2) var f1f7_4 = safeConvert[int64](f1_2) * safeConvert[int64](f7_2)
var f1f8_2 = cast[int64](f1_2) * cast[int64](f8) var f1f8_2 = safeConvert[int64](f1_2) * safeConvert[int64](f8)
var f1f9_76 = cast[int64](f1_2) * cast[int64](f9_38) var f1f9_76 = safeConvert[int64](f1_2) * safeConvert[int64](f9_38)
var f2f2 = cast[int64](f2) * cast[int64](f2) var f2f2 = safeConvert[int64](f2) * safeConvert[int64](f2)
var f2f3_2 = cast[int64](f2_2) * cast[int64](f3) var f2f3_2 = safeConvert[int64](f2_2) * safeConvert[int64](f3)
var f2f4_2 = cast[int64](f2_2) * cast[int64](f4) var f2f4_2 = safeConvert[int64](f2_2) * safeConvert[int64](f4)
var f2f5_2 = cast[int64](f2_2) * cast[int64](f5) var f2f5_2 = safeConvert[int64](f2_2) * safeConvert[int64](f5)
var f2f6_2 = cast[int64](f2_2) * cast[int64](f6) var f2f6_2 = safeConvert[int64](f2_2) * safeConvert[int64](f6)
var f2f7_2 = cast[int64](f2_2) * cast[int64](f7) var f2f7_2 = safeConvert[int64](f2_2) * safeConvert[int64](f7)
var f2f8_38 = cast[int64](f2_2) * cast[int64](f8_19) var f2f8_38 = safeConvert[int64](f2_2) * safeConvert[int64](f8_19)
var f2f9_38 = cast[int64](f2) * cast[int64](f9_38) var f2f9_38 = safeConvert[int64](f2) * safeConvert[int64](f9_38)
var f3f3_2 = cast[int64](f3_2) * cast[int64](f3) var f3f3_2 = safeConvert[int64](f3_2) * safeConvert[int64](f3)
var f3f4_2 = cast[int64](f3_2) * cast[int64](f4) var f3f4_2 = safeConvert[int64](f3_2) * safeConvert[int64](f4)
var f3f5_4 = cast[int64](f3_2) * cast[int64](f5_2) var f3f5_4 = safeConvert[int64](f3_2) * safeConvert[int64](f5_2)
var f3f6_2 = cast[int64](f3_2) * cast[int64](f6) var f3f6_2 = safeConvert[int64](f3_2) * safeConvert[int64](f6)
var f3f7_76 = cast[int64](f3_2) * cast[int64](f7_38) var f3f7_76 = safeConvert[int64](f3_2) * safeConvert[int64](f7_38)
var f3f8_38 = cast[int64](f3_2) * cast[int64](f8_19) var f3f8_38 = safeConvert[int64](f3_2) * safeConvert[int64](f8_19)
var f3f9_76 = cast[int64](f3_2) * cast[int64](f9_38) var f3f9_76 = safeConvert[int64](f3_2) * safeConvert[int64](f9_38)
var f4f4 = cast[int64](f4) * cast[int64](f4) var f4f4 = safeConvert[int64](f4) * safeConvert[int64](f4)
var f4f5_2 = cast[int64](f4_2) * cast[int64](f5) var f4f5_2 = safeConvert[int64](f4_2) * safeConvert[int64](f5)
var f4f6_38 = cast[int64](f4_2) * cast[int64](f6_19) var f4f6_38 = safeConvert[int64](f4_2) * safeConvert[int64](f6_19)
var f4f7_38 = cast[int64](f4) * cast[int64](f7_38) var f4f7_38 = safeConvert[int64](f4) * safeConvert[int64](f7_38)
var f4f8_38 = cast[int64](f4_2) * cast[int64](f8_19) var f4f8_38 = safeConvert[int64](f4_2) * safeConvert[int64](f8_19)
var f4f9_38 = cast[int64](f4) * cast[int64](f9_38) var f4f9_38 = safeConvert[int64](f4) * safeConvert[int64](f9_38)
var f5f5_38 = cast[int64](f5) * cast[int64](f5_38) var f5f5_38 = safeConvert[int64](f5) * safeConvert[int64](f5_38)
var f5f6_38 = cast[int64](f5_2) * cast[int64](f6_19) var f5f6_38 = safeConvert[int64](f5_2) * safeConvert[int64](f6_19)
var f5f7_76 = cast[int64](f5_2) * cast[int64](f7_38) var f5f7_76 = safeConvert[int64](f5_2) * safeConvert[int64](f7_38)
var f5f8_38 = cast[int64](f5_2) * cast[int64](f8_19) var f5f8_38 = safeConvert[int64](f5_2) * safeConvert[int64](f8_19)
var f5f9_76 = cast[int64](f5_2) * cast[int64](f9_38) var f5f9_76 = safeConvert[int64](f5_2) * safeConvert[int64](f9_38)
var f6f6_19 = cast[int64](f6) * cast[int64](f6_19) var f6f6_19 = safeConvert[int64](f6) * safeConvert[int64](f6_19)
var f6f7_38 = cast[int64](f6) * cast[int64](f7_38) var f6f7_38 = safeConvert[int64](f6) * safeConvert[int64](f7_38)
var f6f8_38 = cast[int64](f6_2) * cast[int64](f8_19) var f6f8_38 = safeConvert[int64](f6_2) * safeConvert[int64](f8_19)
var f6f9_38 = cast[int64](f6) * cast[int64](f9_38) var f6f9_38 = safeConvert[int64](f6) * safeConvert[int64](f9_38)
var f7f7_38 = cast[int64](f7) * cast[int64](f7_38) var f7f7_38 = safeConvert[int64](f7) * safeConvert[int64](f7_38)
var f7f8_38 = cast[int64](f7_2) * cast[int64](f8_19) var f7f8_38 = safeConvert[int64](f7_2) * safeConvert[int64](f8_19)
var f7f9_76 = cast[int64](f7_2) * cast[int64](f9_38) var f7f9_76 = safeConvert[int64](f7_2) * safeConvert[int64](f9_38)
var f8f8_19 = cast[int64](f8) * cast[int64](f8_19) var f8f8_19 = safeConvert[int64](f8) * safeConvert[int64](f8_19)
var f8f9_38 = cast[int64](f8) * cast[int64](f9_38) var f8f9_38 = safeConvert[int64](f8) * safeConvert[int64](f9_38)
var f9f9_38 = cast[int64](f9) * cast[int64](f9_38) var f9f9_38 = safeConvert[int64](f9) * safeConvert[int64](f9_38)
var var
c0, c1, c2, c3, c4, c5, c6, c7, c8, c9: int64 c0, c1, c2, c3, c4, c5, c6, c7, c8, c9: int64
h0: int64 = f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38 h0: int64 = f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38
@ -834,7 +837,7 @@ proc geFromBytesNegateVartime(h: var GeP3, s: openArray[byte]): int32 =
return -1; return -1;
feMul(h.x, h.x, SqrTm1) feMul(h.x, h.x, SqrTm1)
if feIsNegative(h.x) == cast[int32](s[31] shr 7): if feIsNegative(h.x) == safeConvert[int32](s[31] shr 7):
feNeg(h.x, h.x) feNeg(h.x, h.x)
feMul(h.t, h.x, h.y) feMul(h.t, h.x, h.y)
@ -956,14 +959,14 @@ proc equal(b, c: int8): byte =
var ub = cast[byte](b) var ub = cast[byte](b)
var uc = cast[byte](c) var uc = cast[byte](c)
var x = ub xor uc var x = ub xor uc
var y = cast[uint32](x) var y = safeConvert[uint32](x)
y = y - 1 y = y - 1
y = y shr 31 y = y shr 31
result = cast[byte](y) result = cast[byte](y)
proc negative(b: int8): byte = proc negative(b: int8): byte =
var x = cast[uint64](b) var x = cast[uint8](b)
x = x shr 63 x = x shr 7
result = cast[byte](x) result = cast[byte](x)
proc cmov(t: var GePrecomp, u: GePrecomp, b: byte) = proc cmov(t: var GePrecomp, u: GePrecomp, b: byte) =

2
libp2p/crypto/hkdf.nim
View File

@ -15,7 +15,7 @@ else:
{.push raises: [].} {.push raises: [].}
import nimcrypto import nimcrypto
import bearssl/[kdf, rand, hash] import bearssl/[kdf, hash]
type HkdfResult*[len: static int] = array[len, byte] type HkdfResult*[len: static int] = array[len, byte]

140
libp2p/crypto/minasn1.nim
View File

@ -18,6 +18,7 @@ import stew/[endians2, results, ctops]
export results export results
# We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures. # We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures.
import nimcrypto/utils as ncrutils import nimcrypto/utils as ncrutils
import ../utility
type type
Asn1Error* {.pure.} = enum Asn1Error* {.pure.} = enum
@ -119,7 +120,7 @@ template toOpenArray*(af: Asn1Field): untyped =
template isEmpty*(ab: Asn1Buffer): bool = template isEmpty*(ab: Asn1Buffer): bool =
ab.offset >= len(ab.buffer) ab.offset >= len(ab.buffer)
template isEnough*(ab: Asn1Buffer, length: int): bool = template isEnough*(ab: Asn1Buffer, length: int64): bool =
len(ab.buffer) >= ab.offset + length len(ab.buffer) >= ab.offset + length
proc len*[T: Asn1Buffer|Asn1Composite](abc: T): int {.inline.} = proc len*[T: Asn1Buffer|Asn1Composite](abc: T): int {.inline.} =
@ -344,32 +345,6 @@ proc asn1EncodeTag[T: SomeUnsignedInt](dest: var openArray[byte],
dest[k - 1] = dest[k - 1] and 0x7F'u8 dest[k - 1] = dest[k - 1] and 0x7F'u8
res res
proc asn1EncodeOid*(dest: var openArray[byte], value: openArray[int]): int =
## Encode array of integers ``value`` as ASN.1 DER `OBJECT IDENTIFIER` and
## return number of bytes (octets) used.
##
## If length of ``dest`` is less then number of required bytes to encode
## ``value``, then result of encoding will not be stored in ``dest``
## but number of bytes (octets) required will be returned.
var buffer: array[16, byte]
var res = 1
var oidlen = 1
for i in 2..<len(value):
oidlen += asn1EncodeTag(buffer, cast[uint64](value[i]))
res += asn1EncodeLength(buffer, uint64(oidlen))
res += oidlen
if len(dest) >= res:
let last = dest.high
var offset = 1
dest[0] = Asn1Tag.Oid.code()
offset += asn1EncodeLength(dest.toOpenArray(offset, last), uint64(oidlen))
dest[offset] = cast[byte](value[0] * 40 + value[1])
offset += 1
for i in 2..<len(value):
offset += asn1EncodeTag(dest.toOpenArray(offset, last),
cast[uint64](value[i]))
res
proc asn1EncodeOid*(dest: var openArray[byte], value: openArray[byte]): int = proc asn1EncodeOid*(dest: var openArray[byte], value: openArray[byte]): int =
## Encode array of bytes ``value`` as ASN.1 DER `OBJECT IDENTIFIER` and return ## Encode array of bytes ``value`` as ASN.1 DER `OBJECT IDENTIFIER` and return
## number of bytes (octets) used. ## number of bytes (octets) used.
@ -443,26 +418,29 @@ proc asn1EncodeContextTag*(dest: var openArray[byte], value: openArray[byte],
copyMem(addr dest[1 + lenlen], unsafeAddr value[0], len(value)) copyMem(addr dest[1 + lenlen], unsafeAddr value[0], len(value))
res res
proc getLength(ab: var Asn1Buffer): Asn1Result[uint64] = proc getLength(ab: var Asn1Buffer): Asn1Result[int] =
## Decode length part of ASN.1 TLV triplet. ## Decode length part of ASN.1 TLV triplet.
if not ab.isEmpty(): if not ab.isEmpty():
let b = ab.buffer[ab.offset] let b = ab.buffer[ab.offset]
if (b and 0x80'u8) == 0x00'u8: if (b and 0x80'u8) == 0x00'u8:
let length = cast[uint64](b) let length = safeConvert[int](b)
ab.offset += 1 ab.offset += 1
return ok(length) return ok(length)
if b == 0x80'u8: if b == 0x80'u8:
return err(Asn1Error.Indefinite) return err(Asn1Error.Indefinite)
if b == 0xFF'u8: if b == 0xFF'u8:
return err(Asn1Error.Incorrect) return err(Asn1Error.Incorrect)
let octets = cast[uint64](b and 0x7F'u8) let octets = safeConvert[int](b and 0x7F'u8)
if octets > 8'u64: if octets > 8:
return err(Asn1Error.Overflow) return err(Asn1Error.Overflow)
if ab.isEnough(int(octets)): if ab.isEnough(octets):
var length: uint64 = 0 var lengthU: uint64 = 0
for i in 0..<int(octets): for i in 0..<octets:
length = (length shl 8) or cast[uint64](ab.buffer[ab.offset + i + 1]) lengthU = (lengthU shl 8) or safeConvert[uint64](ab.buffer[ab.offset + i + 1])
ab.offset = ab.offset + int(octets) + 1 if lengthU > uint64(int64.high):
return err(Asn1Error.Overflow)
let length = int(lengthU)
ab.offset = ab.offset + octets + 1
return ok(length) return ok(length)
else: else:
return err(Asn1Error.Incomplete) return err(Asn1Error.Incomplete)
@ -474,8 +452,8 @@ proc getTag(ab: var Asn1Buffer, tag: var int): Asn1Result[Asn1Class] =
if not ab.isEmpty(): if not ab.isEmpty():
let let
b = ab.buffer[ab.offset] b = ab.buffer[ab.offset]
c = int((b and 0xC0'u8) shr 6) c = safeConvert[int]((b and 0xC0'u8) shr 6)
tag = int(b and 0x3F) tag = safeConvert[int](b and 0x3F)
ab.offset += 1 ab.offset += 1
if c >= 0 and c < 4: if c >= 0 and c < 4:
ok(cast[Asn1Class](c)) ok(cast[Asn1Class](c))
@ -489,7 +467,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
var var
field: Asn1Field field: Asn1Field
tag, ttag, offset: int tag, ttag, offset: int
length, tlength: uint64 length, tlength: int
aclass: Asn1Class aclass: Asn1Class
inclass: bool inclass: bool
@ -519,7 +497,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
if length != 1: if length != 1:
return err(Asn1Error.Incorrect) return err(Asn1Error.Incorrect)
if not ab.isEnough(int(length)): if not ab.isEnough(length):
return err(Asn1Error.Incomplete) return err(Asn1Error.Incomplete)
let b = ab.buffer[ab.offset] let b = ab.buffer[ab.offset]
@ -527,7 +505,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
return err(Asn1Error.Incorrect) return err(Asn1Error.Incorrect)
field = Asn1Field(kind: Asn1Tag.Boolean, klass: aclass, field = Asn1Field(kind: Asn1Tag.Boolean, klass: aclass,
index: ttag, offset: int(ab.offset), index: ttag, offset: ab.offset,
length: 1, buffer: ab.buffer) length: 1, buffer: ab.buffer)
field.vbool = (b == 0xFF'u8) field.vbool = (b == 0xFF'u8)
ab.offset += 1 ab.offset += 1
@ -538,12 +516,12 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
if length == 0: if length == 0:
return err(Asn1Error.Incorrect) return err(Asn1Error.Incorrect)
if not ab.isEnough(int(length)): if not ab.isEnough(length):
return err(Asn1Error.Incomplete) return err(Asn1Error.Incomplete)
# Count number of leading zeroes # Count number of leading zeroes
var zc = 0 var zc = 0
while (zc < int(length)) and (ab.buffer[ab.offset + zc] == 0x00'u8): while (zc < length) and (ab.buffer[ab.offset + zc] == 0x00'u8):
inc(zc) inc(zc)
if zc > 1: if zc > 1:
@ -552,45 +530,45 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
if zc == 0: if zc == 0:
# Negative or Positive integer # Negative or Positive integer
field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass, field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass,
index: ttag, offset: int(ab.offset), index: ttag, offset: ab.offset,
length: int(length), buffer: ab.buffer) length: length, buffer: ab.buffer)
if (ab.buffer[ab.offset] and 0x80'u8) == 0x80'u8: if (ab.buffer[ab.offset] and 0x80'u8) == 0x80'u8:
# Negative integer # Negative integer
if length <= 8: if length <= 8:
# We need this transformation because our field.vint is uint64. # We need this transformation because our field.vint is uint64.
for i in 0 ..< 8: for i in 0 ..< 8:
if i < 8 - int(length): if i < 8 - length:
field.vint = (field.vint shl 8) or 0xFF'u64 field.vint = (field.vint shl 8) or 0xFF'u64
else: else:
let offset = ab.offset + i - (8 - int(length)) let offset = ab.offset + i - (8 - length)
field.vint = (field.vint shl 8) or uint64(ab.buffer[offset]) field.vint = (field.vint shl 8) or safeConvert[uint64](ab.buffer[offset])
else: else:
# Positive integer # Positive integer
if length <= 8: if length <= 8:
for i in 0 ..< int(length): for i in 0 ..< length:
field.vint = (field.vint shl 8) or field.vint = (field.vint shl 8) or
uint64(ab.buffer[ab.offset + i]) safeConvert[uint64](ab.buffer[ab.offset + i])
ab.offset += int(length) ab.offset += length
return ok(field) return ok(field)
else: else:
if length == 1: if length == 1:
# Zero value integer # Zero value integer
field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass, field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass,
index: ttag, offset: int(ab.offset), index: ttag, offset: ab.offset,
length: int(length), vint: 0'u64, length: length, vint: 0'u64,
buffer: ab.buffer) buffer: ab.buffer)
ab.offset += int(length) ab.offset += length
return ok(field) return ok(field)
else: else:
# Positive integer with leading zero # Positive integer with leading zero
field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass, field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass,
index: ttag, offset: int(ab.offset) + 1, index: ttag, offset: ab.offset + 1,
length: int(length) - 1, buffer: ab.buffer) length: length - 1, buffer: ab.buffer)
if length <= 9: if length <= 9:
for i in 1 ..< int(length): for i in 1 ..< length:
field.vint = (field.vint shl 8) or field.vint = (field.vint shl 8) or
uint64(ab.buffer[ab.offset + i]) safeConvert[uint64](ab.buffer[ab.offset + i])
ab.offset += int(length) ab.offset += length
return ok(field) return ok(field)
of Asn1Tag.BitString.code(): of Asn1Tag.BitString.code():
@ -606,13 +584,13 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
else: else:
# Zero-length BIT STRING. # Zero-length BIT STRING.
field = Asn1Field(kind: Asn1Tag.BitString, klass: aclass, field = Asn1Field(kind: Asn1Tag.BitString, klass: aclass,
index: ttag, offset: int(ab.offset + 1), index: ttag, offset: ab.offset + 1,
length: 0, ubits: 0, buffer: ab.buffer) length: 0, ubits: 0, buffer: ab.buffer)
ab.offset += int(length) ab.offset += length
return ok(field) return ok(field)
else: else:
if not ab.isEnough(int(length)): if not ab.isEnough(length):
return err(Asn1Error.Incomplete) return err(Asn1Error.Incomplete)
let unused = ab.buffer[ab.offset] let unused = ab.buffer[ab.offset]
@ -620,27 +598,27 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
# Number of unused bits should not be bigger then `7`. # Number of unused bits should not be bigger then `7`.
return err(Asn1Error.Incorrect) return err(Asn1Error.Incorrect)
let mask = (1'u8 shl int(unused)) - 1'u8 let mask = (1'u8 shl safeConvert[int](unused)) - 1'u8
if (ab.buffer[ab.offset + int(length) - 1] and mask) != 0x00'u8: if (ab.buffer[ab.offset + length - 1] and mask) != 0x00'u8:
## All unused bits should be set to `0`. ## All unused bits should be set to `0`.
return err(Asn1Error.Incorrect) return err(Asn1Error.Incorrect)
field = Asn1Field(kind: Asn1Tag.BitString, klass: aclass, field = Asn1Field(kind: Asn1Tag.BitString, klass: aclass,
index: ttag, offset: int(ab.offset + 1), index: ttag, offset: ab.offset + 1,
length: int(length - 1), ubits: int(unused), length: length - 1, ubits: safeConvert[int](unused),
buffer: ab.buffer) buffer: ab.buffer)
ab.offset += int(length) ab.offset += length
return ok(field) return ok(field)
of Asn1Tag.OctetString.code(): of Asn1Tag.OctetString.code():
# OCTET STRING # OCTET STRING
if not ab.isEnough(int(length)): if not ab.isEnough(length):
return err(Asn1Error.Incomplete) return err(Asn1Error.Incomplete)
field = Asn1Field(kind: Asn1Tag.OctetString, klass: aclass, field = Asn1Field(kind: Asn1Tag.OctetString, klass: aclass,
index: ttag, offset: int(ab.offset), index: ttag, offset: ab.offset,
length: int(length), buffer: ab.buffer) length: length, buffer: ab.buffer)
ab.offset += int(length) ab.offset += length
return ok(field) return ok(field)
of Asn1Tag.Null.code(): of Asn1Tag.Null.code():
@ -649,30 +627,30 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
return err(Asn1Error.Incorrect) return err(Asn1Error.Incorrect)
field = Asn1Field(kind: Asn1Tag.Null, klass: aclass, index: ttag, field = Asn1Field(kind: Asn1Tag.Null, klass: aclass, index: ttag,
offset: int(ab.offset), length: 0, buffer: ab.buffer) offset: ab.offset, length: 0, buffer: ab.buffer)
ab.offset += int(length) ab.offset += length
return ok(field) return ok(field)
of Asn1Tag.Oid.code(): of Asn1Tag.Oid.code():
# OID # OID
if not ab.isEnough(int(length)): if not ab.isEnough(length):
return err(Asn1Error.Incomplete) return err(Asn1Error.Incomplete)
field = Asn1Field(kind: Asn1Tag.Oid, klass: aclass, field = Asn1Field(kind: Asn1Tag.Oid, klass: aclass,
index: ttag, offset: int(ab.offset), index: ttag, offset: ab.offset,
length: int(length), buffer: ab.buffer) length: length, buffer: ab.buffer)
ab.offset += int(length) ab.offset += length
return ok(field) return ok(field)
of Asn1Tag.Sequence.code(): of Asn1Tag.Sequence.code():
# SEQUENCE # SEQUENCE
if not ab.isEnough(int(length)): if not ab.isEnough(length):
return err(Asn1Error.Incomplete) return err(Asn1Error.Incomplete)
field = Asn1Field(kind: Asn1Tag.Sequence, klass: aclass, field = Asn1Field(kind: Asn1Tag.Sequence, klass: aclass,
index: ttag, offset: int(ab.offset), index: ttag, offset: ab.offset,
length: int(length), buffer: ab.buffer) length: length, buffer: ab.buffer)
ab.offset += int(length) ab.offset += length
return ok(field) return ok(field)
else: else:

2
libp2p/crypto/rsa.nim
View File

@ -686,7 +686,7 @@ proc `==`*(a, b: RsaPrivateKey): bool =
false false
else: else:
if a.seck.nBitlen == b.seck.nBitlen: if a.seck.nBitlen == b.seck.nBitlen:
if cast[int](a.seck.nBitlen) > 0: if a.seck.nBitlen > 0'u:
let r1 = CT.isEqual(getArray(a.buffer, a.seck.p, a.seck.plen), let r1 = CT.isEqual(getArray(a.buffer, a.seck.p, a.seck.plen),
getArray(b.buffer, b.seck.p, b.seck.plen)) getArray(b.buffer, b.seck.p, b.seck.plen))
let r2 = CT.isEqual(getArray(a.buffer, a.seck.q, a.seck.qlen), let r2 = CT.isEqual(getArray(a.buffer, a.seck.q, a.seck.qlen),

3
libp2p/crypto/secp.nim
View File

@ -35,9 +35,6 @@ type
SkSignature* = distinct secp256k1.SkSignature SkSignature* = distinct secp256k1.SkSignature
SkKeyPair* = distinct secp256k1.SkKeyPair SkKeyPair* = distinct secp256k1.SkKeyPair
template pubkey*(v: SkKeyPair): SkPublicKey = SkPublicKey(secp256k1.SkKeyPair(v).pubkey)
template seckey*(v: SkKeyPair): SkPrivateKey = SkPrivateKey(secp256k1.SkKeyPair(v).seckey)
proc random*(t: typedesc[SkPrivateKey], rng: var HmacDrbgContext): SkPrivateKey = proc random*(t: typedesc[SkPrivateKey], rng: var HmacDrbgContext): SkPrivateKey =
#TODO is there a better way? #TODO is there a better way?
var rngPtr = addr rng var rngPtr = addr rng

96
libp2p/daemon/daemonapi.nim
View File

@ -17,7 +17,7 @@ import std/[os, osproc, strutils, tables, strtabs, sequtils]
import pkg/[chronos, chronicles] import pkg/[chronos, chronicles]
import ../varint, ../multiaddress, ../multicodec, ../cid, ../peerid import ../varint, ../multiaddress, ../multicodec, ../cid, ../peerid
import ../wire, ../multihash, ../protobuf/minprotobuf, ../errors import ../wire, ../multihash, ../protobuf/minprotobuf, ../errors
import ../crypto/crypto import ../crypto/crypto, ../utility
export export
peerid, multiaddress, multicodec, multihash, cid, crypto, wire, errors peerid, multiaddress, multicodec, multihash, cid, crypto, wire, errors
@ -170,7 +170,7 @@ proc requestIdentity(): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/conn.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/conn.go
## Processing function `doIdentify(req *pb.Request)`. ## Processing function `doIdentify(req *pb.Request)`.
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
result.write(1, cast[uint](RequestType.IDENTIFY)) result.write(1, safeConvert[uint](RequestType.IDENTIFY))
result.finish() result.finish()
proc requestConnect(peerid: PeerId, proc requestConnect(peerid: PeerId,
@ -185,7 +185,7 @@ proc requestConnect(peerid: PeerId,
msg.write(2, item.data.buffer) msg.write(2, item.data.buffer)
if timeout > 0: if timeout > 0:
msg.write(3, hint64(timeout)) msg.write(3, hint64(timeout))
result.write(1, cast[uint](RequestType.CONNECT)) result.write(1, safeConvert[uint](RequestType.CONNECT))
result.write(2, msg) result.write(2, msg)
result.finish() result.finish()
@ -195,7 +195,7 @@ proc requestDisconnect(peerid: PeerId): ProtoBuffer =
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, peerid) msg.write(1, peerid)
result.write(1, cast[uint](RequestType.DISCONNECT)) result.write(1, safeConvert[uint](RequestType.DISCONNECT))
result.write(7, msg) result.write(7, msg)
result.finish() result.finish()
@ -211,7 +211,7 @@ proc requestStreamOpen(peerid: PeerId,
msg.write(2, item) msg.write(2, item)
if timeout > 0: if timeout > 0:
msg.write(3, hint64(timeout)) msg.write(3, hint64(timeout))
result.write(1, cast[uint](RequestType.STREAM_OPEN)) result.write(1, safeConvert[uint](RequestType.STREAM_OPEN))
result.write(3, msg) result.write(3, msg)
result.finish() result.finish()
@ -224,7 +224,7 @@ proc requestStreamHandler(address: MultiAddress,
msg.write(1, address.data.buffer) msg.write(1, address.data.buffer)
for item in protocols: for item in protocols:
msg.write(2, item) msg.write(2, item)
result.write(1, cast[uint](RequestType.STREAM_HANDLER)) result.write(1, safeConvert[uint](RequestType.STREAM_HANDLER))
result.write(4, msg) result.write(4, msg)
result.finish() result.finish()
@ -232,13 +232,13 @@ proc requestListPeers(): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/conn.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/conn.go
## Processing function `doListPeers(req *pb.Request)` ## Processing function `doListPeers(req *pb.Request)`
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
result.write(1, cast[uint](RequestType.LIST_PEERS)) result.write(1, safeConvert[uint](RequestType.LIST_PEERS))
result.finish() result.finish()
proc requestDHTFindPeer(peer: PeerId, timeout = 0): ProtoBuffer = proc requestDHTFindPeer(peer: PeerId, timeout = 0): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
## Processing function `doDHTFindPeer(req *pb.DHTRequest)`. ## Processing function `doDHTFindPeer(req *pb.DHTRequest)`.
let msgid = cast[uint](DHTRequestType.FIND_PEER) let msgid = safeConvert[uint](DHTRequestType.FIND_PEER)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
@ -246,7 +246,7 @@ proc requestDHTFindPeer(peer: PeerId, timeout = 0): ProtoBuffer =
if timeout > 0: if timeout > 0:
msg.write(7, hint64(timeout)) msg.write(7, hint64(timeout))
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.DHT)) result.write(1, safeConvert[uint](RequestType.DHT))
result.write(5, msg) result.write(5, msg)
result.finish() result.finish()
@ -254,7 +254,7 @@ proc requestDHTFindPeersConnectedToPeer(peer: PeerId,
timeout = 0): ProtoBuffer = timeout = 0): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
## Processing function `doDHTFindPeersConnectedToPeer(req *pb.DHTRequest)`. ## Processing function `doDHTFindPeersConnectedToPeer(req *pb.DHTRequest)`.
let msgid = cast[uint](DHTRequestType.FIND_PEERS_CONNECTED_TO_PEER) let msgid = safeConvert[uint](DHTRequestType.FIND_PEERS_CONNECTED_TO_PEER)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
@ -262,7 +262,7 @@ proc requestDHTFindPeersConnectedToPeer(peer: PeerId,
if timeout > 0: if timeout > 0:
msg.write(7, hint64(timeout)) msg.write(7, hint64(timeout))
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.DHT)) result.write(1, safeConvert[uint](RequestType.DHT))
result.write(5, msg) result.write(5, msg)
result.finish() result.finish()
@ -270,7 +270,7 @@ proc requestDHTFindProviders(cid: Cid,
count: uint32, timeout = 0): ProtoBuffer = count: uint32, timeout = 0): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
## Processing function `doDHTFindProviders(req *pb.DHTRequest)`. ## Processing function `doDHTFindProviders(req *pb.DHTRequest)`.
let msgid = cast[uint](DHTRequestType.FIND_PROVIDERS) let msgid = safeConvert[uint](DHTRequestType.FIND_PROVIDERS)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
@ -279,14 +279,14 @@ proc requestDHTFindProviders(cid: Cid,
if timeout > 0: if timeout > 0:
msg.write(7, hint64(timeout)) msg.write(7, hint64(timeout))
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.DHT)) result.write(1, safeConvert[uint](RequestType.DHT))
result.write(5, msg) result.write(5, msg)
result.finish() result.finish()
proc requestDHTGetClosestPeers(key: string, timeout = 0): ProtoBuffer = proc requestDHTGetClosestPeers(key: string, timeout = 0): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
## Processing function `doDHTGetClosestPeers(req *pb.DHTRequest)`. ## Processing function `doDHTGetClosestPeers(req *pb.DHTRequest)`.
let msgid = cast[uint](DHTRequestType.GET_CLOSEST_PEERS) let msgid = safeConvert[uint](DHTRequestType.GET_CLOSEST_PEERS)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
@ -294,14 +294,14 @@ proc requestDHTGetClosestPeers(key: string, timeout = 0): ProtoBuffer =
if timeout > 0: if timeout > 0:
msg.write(7, hint64(timeout)) msg.write(7, hint64(timeout))
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.DHT)) result.write(1, safeConvert[uint](RequestType.DHT))
result.write(5, msg) result.write(5, msg)
result.finish() result.finish()
proc requestDHTGetPublicKey(peer: PeerId, timeout = 0): ProtoBuffer = proc requestDHTGetPublicKey(peer: PeerId, timeout = 0): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
## Processing function `doDHTGetPublicKey(req *pb.DHTRequest)`. ## Processing function `doDHTGetPublicKey(req *pb.DHTRequest)`.
let msgid = cast[uint](DHTRequestType.GET_PUBLIC_KEY) let msgid = safeConvert[uint](DHTRequestType.GET_PUBLIC_KEY)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
@ -309,14 +309,14 @@ proc requestDHTGetPublicKey(peer: PeerId, timeout = 0): ProtoBuffer =
if timeout > 0: if timeout > 0:
msg.write(7, hint64(timeout)) msg.write(7, hint64(timeout))
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.DHT)) result.write(1, safeConvert[uint](RequestType.DHT))
result.write(5, msg) result.write(5, msg)
result.finish() result.finish()
proc requestDHTGetValue(key: string, timeout = 0): ProtoBuffer = proc requestDHTGetValue(key: string, timeout = 0): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
## Processing function `doDHTGetValue(req *pb.DHTRequest)`. ## Processing function `doDHTGetValue(req *pb.DHTRequest)`.
let msgid = cast[uint](DHTRequestType.GET_VALUE) let msgid = safeConvert[uint](DHTRequestType.GET_VALUE)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
@ -324,14 +324,14 @@ proc requestDHTGetValue(key: string, timeout = 0): ProtoBuffer =
if timeout > 0: if timeout > 0:
msg.write(7, hint64(timeout)) msg.write(7, hint64(timeout))
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.DHT)) result.write(1, safeConvert[uint](RequestType.DHT))
result.write(5, msg) result.write(5, msg)
result.finish() result.finish()
proc requestDHTSearchValue(key: string, timeout = 0): ProtoBuffer = proc requestDHTSearchValue(key: string, timeout = 0): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
## Processing function `doDHTSearchValue(req *pb.DHTRequest)`. ## Processing function `doDHTSearchValue(req *pb.DHTRequest)`.
let msgid = cast[uint](DHTRequestType.SEARCH_VALUE) let msgid = safeConvert[uint](DHTRequestType.SEARCH_VALUE)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
@ -339,7 +339,7 @@ proc requestDHTSearchValue(key: string, timeout = 0): ProtoBuffer =
if timeout > 0: if timeout > 0:
msg.write(7, hint64(timeout)) msg.write(7, hint64(timeout))
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.DHT)) result.write(1, safeConvert[uint](RequestType.DHT))
result.write(5, msg) result.write(5, msg)
result.finish() result.finish()
@ -347,7 +347,7 @@ proc requestDHTPutValue(key: string, value: openArray[byte],
timeout = 0): ProtoBuffer = timeout = 0): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
## Processing function `doDHTPutValue(req *pb.DHTRequest)`. ## Processing function `doDHTPutValue(req *pb.DHTRequest)`.
let msgid = cast[uint](DHTRequestType.PUT_VALUE) let msgid = safeConvert[uint](DHTRequestType.PUT_VALUE)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
@ -356,14 +356,14 @@ proc requestDHTPutValue(key: string, value: openArray[byte],
if timeout > 0: if timeout > 0:
msg.write(7, hint64(timeout)) msg.write(7, hint64(timeout))
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.DHT)) result.write(1, uint(RequestType.DHT))
result.write(5, msg) result.write(5, msg)
result.finish() result.finish()
proc requestDHTProvide(cid: Cid, timeout = 0): ProtoBuffer = proc requestDHTProvide(cid: Cid, timeout = 0): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
## Processing function `doDHTProvide(req *pb.DHTRequest)`. ## Processing function `doDHTProvide(req *pb.DHTRequest)`.
let msgid = cast[uint](DHTRequestType.PROVIDE) let msgid = safeConvert[uint](DHTRequestType.PROVIDE)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
@ -371,13 +371,13 @@ proc requestDHTProvide(cid: Cid, timeout = 0): ProtoBuffer =
if timeout > 0: if timeout > 0:
msg.write(7, hint64(timeout)) msg.write(7, hint64(timeout))
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.DHT)) result.write(1, safeConvert[uint](RequestType.DHT))
result.write(5, msg) result.write(5, msg)
result.finish() result.finish()
proc requestCMTagPeer(peer: PeerId, tag: string, weight: int): ProtoBuffer = proc requestCMTagPeer(peer: PeerId, tag: string, weight: int): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/connmgr.go#L18 ## https://github.com/libp2p/go-libp2p-daemon/blob/master/connmgr.go#L18
let msgid = cast[uint](ConnManagerRequestType.TAG_PEER) let msgid = safeConvert[uint](ConnManagerRequestType.TAG_PEER)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
@ -385,83 +385,83 @@ proc requestCMTagPeer(peer: PeerId, tag: string, weight: int): ProtoBuffer =
msg.write(3, tag) msg.write(3, tag)
msg.write(4, hint64(weight)) msg.write(4, hint64(weight))
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.CONNMANAGER)) result.write(1, safeConvert[uint](RequestType.CONNMANAGER))
result.write(6, msg) result.write(6, msg)
result.finish() result.finish()
proc requestCMUntagPeer(peer: PeerId, tag: string): ProtoBuffer = proc requestCMUntagPeer(peer: PeerId, tag: string): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/connmgr.go#L33 ## https://github.com/libp2p/go-libp2p-daemon/blob/master/connmgr.go#L33
let msgid = cast[uint](ConnManagerRequestType.UNTAG_PEER) let msgid = safeConvert[uint](ConnManagerRequestType.UNTAG_PEER)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
msg.write(2, peer) msg.write(2, peer)
msg.write(3, tag) msg.write(3, tag)
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.CONNMANAGER)) result.write(1, safeConvert[uint](RequestType.CONNMANAGER))
result.write(6, msg) result.write(6, msg)
result.finish() result.finish()
proc requestCMTrim(): ProtoBuffer = proc requestCMTrim(): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/connmgr.go#L47 ## https://github.com/libp2p/go-libp2p-daemon/blob/master/connmgr.go#L47
let msgid = cast[uint](ConnManagerRequestType.TRIM) let msgid = safeConvert[uint](ConnManagerRequestType.TRIM)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.CONNMANAGER)) result.write(1, safeConvert[uint](RequestType.CONNMANAGER))
result.write(6, msg) result.write(6, msg)
result.finish() result.finish()
proc requestPSGetTopics(): ProtoBuffer = proc requestPSGetTopics(): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go
## Processing function `doPubsubGetTopics(req *pb.PSRequest)`. ## Processing function `doPubsubGetTopics(req *pb.PSRequest)`.
let msgid = cast[uint](PSRequestType.GET_TOPICS) let msgid = safeConvert[uint](PSRequestType.GET_TOPICS)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.PUBSUB)) result.write(1, safeConvert[uint](RequestType.PUBSUB))
result.write(8, msg) result.write(8, msg)
result.finish() result.finish()
proc requestPSListPeers(topic: string): ProtoBuffer = proc requestPSListPeers(topic: string): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go
## Processing function `doPubsubListPeers(req *pb.PSRequest)`. ## Processing function `doPubsubListPeers(req *pb.PSRequest)`.
let msgid = cast[uint](PSRequestType.LIST_PEERS) let msgid = safeConvert[uint](PSRequestType.LIST_PEERS)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
msg.write(2, topic) msg.write(2, topic)
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.PUBSUB)) result.write(1, safeConvert[uint](RequestType.PUBSUB))
result.write(8, msg) result.write(8, msg)
result.finish() result.finish()
proc requestPSPublish(topic: string, data: openArray[byte]): ProtoBuffer = proc requestPSPublish(topic: string, data: openArray[byte]): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go
## Processing function `doPubsubPublish(req *pb.PSRequest)`. ## Processing function `doPubsubPublish(req *pb.PSRequest)`.
let msgid = cast[uint](PSRequestType.PUBLISH) let msgid = safeConvert[uint](PSRequestType.PUBLISH)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
msg.write(2, topic) msg.write(2, topic)
msg.write(3, data) msg.write(3, data)
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.PUBSUB)) result.write(1, safeConvert[uint](RequestType.PUBSUB))
result.write(8, msg) result.write(8, msg)
result.finish() result.finish()
proc requestPSSubscribe(topic: string): ProtoBuffer = proc requestPSSubscribe(topic: string): ProtoBuffer =
## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go ## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go
## Processing function `doPubsubSubscribe(req *pb.PSRequest)`. ## Processing function `doPubsubSubscribe(req *pb.PSRequest)`.
let msgid = cast[uint](PSRequestType.SUBSCRIBE) let msgid = safeConvert[uint](PSRequestType.SUBSCRIBE)
result = initProtoBuffer({WithVarintLength}) result = initProtoBuffer({WithVarintLength})
var msg = initProtoBuffer() var msg = initProtoBuffer()
msg.write(1, msgid) msg.write(1, msgid)
msg.write(2, topic) msg.write(2, topic)
msg.finish() msg.finish()
result.write(1, cast[uint](RequestType.PUBSUB)) result.write(1, safeConvert[uint](RequestType.PUBSUB))
result.write(8, msg) result.write(8, msg)
result.finish() result.finish()
@ -515,7 +515,7 @@ proc socketExists(address: MultiAddress): Future[bool] {.async.} =
var transp = await connect(address) var transp = await connect(address)
await transp.closeWait() await transp.closeWait()
result = true result = true
except: except CatchableError, Defect:
result = false result = false
when defined(windows): when defined(windows):
@ -525,7 +525,7 @@ when defined(windows):
result = cast[int](getCurrentProcessId()) result = cast[int](getCurrentProcessId())
else: else:
proc getProcessId(): int = proc getProcessId(): int =
result = cast[int](posix.getpid()) result = int(posix.getpid())
proc getSocket(pattern: string, proc getSocket(pattern: string,
count: ptr int): Future[MultiAddress] {.async.} = count: ptr int): Future[MultiAddress] {.async.} =
@ -759,12 +759,8 @@ proc newDaemonApi*(flags: set[P2PDaemonFlags] = {},
# Starting daemon process # Starting daemon process
# echo "Starting ", cmd, " ", args.join(" ") # echo "Starting ", cmd, " ", args.join(" ")
api.process = api.process =
try: exceptionToAssert:
startProcess(cmd, "", args, env, {poParentStreams}) startProcess(cmd, "", args, env, {poParentStreams})
except CatchableError as exc:
raise exc
except Exception as exc:
raiseAssert exc.msg
# Waiting until daemon will not be bound to control socket. # Waiting until daemon will not be bound to control socket.
while true: while true:
if not api.process.running(): if not api.process.running():
@ -872,7 +868,7 @@ proc connect*(api: DaemonAPI, peer: PeerId,
timeout)) timeout))
pb.withMessage() do: pb.withMessage() do:
discard discard
except: except CatchableError, Defect:
await api.closeConnection(transp) await api.closeConnection(transp)
proc disconnect*(api: DaemonAPI, peer: PeerId) {.async.} = proc disconnect*(api: DaemonAPI, peer: PeerId) {.async.} =
@ -1033,7 +1029,7 @@ proc enterDhtMessage(pb: ProtoBuffer, rt: DHTResponseType): ProtoBuffer
var dtype: uint var dtype: uint
if pbDhtResponse.getRequiredField(1, dtype).isErr(): if pbDhtResponse.getRequiredField(1, dtype).isErr():
raise newException(DaemonLocalError, "Missing required DHT field `type`!") raise newException(DaemonLocalError, "Missing required DHT field `type`!")
if dtype != cast[uint](rt): if dtype != safeConvert[uint](rt):
raise newException(DaemonLocalError, "Wrong DHT answer type! ") raise newException(DaemonLocalError, "Wrong DHT answer type! ")
var value: seq[byte] var value: seq[byte]
@ -1057,9 +1053,9 @@ proc getDhtMessageType(pb: ProtoBuffer): DHTResponseType
var dtype: uint var dtype: uint
if pb.getRequiredField(1, dtype).isErr(): if pb.getRequiredField(1, dtype).isErr():
raise newException(DaemonLocalError, "Missing required DHT field `type`!") raise newException(DaemonLocalError, "Missing required DHT field `type`!")
if dtype == cast[uint](DHTResponseType.VALUE): if dtype == safeConvert[uint](DHTResponseType.VALUE):
result = DHTResponseType.VALUE result = DHTResponseType.VALUE
elif dtype == cast[uint](DHTResponseType.END): elif dtype == safeConvert[uint](DHTResponseType.END):
result = DHTResponseType.END result = DHTResponseType.END
else: else:
raise newException(DaemonLocalError, "Wrong DHT answer type!") raise newException(DaemonLocalError, "Wrong DHT answer type!")

2
libp2p/dialer.nim
View File

@ -7,7 +7,7 @@
# This file may not be copied, modified, or distributed except according to # This file may not be copied, modified, or distributed except according to
# those terms. # those terms.
import std/[sugar, tables, sequtils] import std/tables
import stew/results import stew/results
import pkg/[chronos, import pkg/[chronos,

1
libp2p/discovery/rendezvousinterface.nim
View File

@ -12,7 +12,6 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import sequtils
import chronos import chronos
import ./discoverymngr, import ./discoverymngr,
../protocols/rendezvous, ../protocols/rendezvous,

18
libp2p/multiaddress.nim
View File

@ -83,7 +83,7 @@ proc ip4StB(s: string, vb: var VBuffer): bool =
if a.family == IpAddressFamily.IPv4: if a.family == IpAddressFamily.IPv4:
vb.writeArray(a.address_v4) vb.writeArray(a.address_v4)
result = true result = true
except: except CatchableError:
discard discard
proc ip4BtS(vb: var VBuffer, s: var string): bool = proc ip4BtS(vb: var VBuffer, s: var string): bool =
@ -106,7 +106,7 @@ proc ip6StB(s: string, vb: var VBuffer): bool =
if a.family == IpAddressFamily.IPv6: if a.family == IpAddressFamily.IPv6:
vb.writeArray(a.address_v6) vb.writeArray(a.address_v6)
result = true result = true
except: except CatchableError:
discard discard
proc ip6BtS(vb: var VBuffer, s: var string): bool = proc ip6BtS(vb: var VBuffer, s: var string): bool =
@ -150,14 +150,14 @@ proc portStB(s: string, vb: var VBuffer): bool =
port[1] = cast[byte](nport and 0xFF) port[1] = cast[byte](nport and 0xFF)
vb.writeArray(port) vb.writeArray(port)
result = true result = true
except: except CatchableError:
discard discard
proc portBtS(vb: var VBuffer, s: var string): bool = proc portBtS(vb: var VBuffer, s: var string): bool =
## Port number bufferToString() implementation. ## Port number bufferToString() implementation.
var port: array[2, byte] var port: array[2, byte]
if vb.readArray(port) == 2: if vb.readArray(port) == 2:
var nport = (cast[uint16](port[0]) shl 8) or cast[uint16](port[1]) var nport = (safeConvert[uint16](port[0]) shl 8) or safeConvert[uint16](port[1])
s = $nport s = $nport
result = true result = true
@ -175,7 +175,7 @@ proc p2pStB(s: string, vb: var VBuffer): bool =
if MultiHash.decode(data, mh).isOk: if MultiHash.decode(data, mh).isOk:
vb.writeSeq(data) vb.writeSeq(data)
result = true result = true
except: except CatchableError:
discard discard
proc p2pBtS(vb: var VBuffer, s: var string): bool = proc p2pBtS(vb: var VBuffer, s: var string): bool =
@ -210,14 +210,14 @@ proc onionStB(s: string, vb: var VBuffer): bool =
address[11] = cast[byte](nport and 0xFF) address[11] = cast[byte](nport and 0xFF)
vb.writeArray(address) vb.writeArray(address)
result = true result = true
except: except CatchableError:
discard discard
proc onionBtS(vb: var VBuffer, s: var string): bool = proc onionBtS(vb: var VBuffer, s: var string): bool =
## ONION address bufferToString() implementation. ## ONION address bufferToString() implementation.
var buf: array[12, byte] var buf: array[12, byte]
if vb.readArray(buf) == 12: if vb.readArray(buf) == 12:
var nport = (cast[uint16](buf[10]) shl 8) or cast[uint16](buf[11]) var nport = (safeConvert[uint16](buf[10]) shl 8) or safeConvert[uint16](buf[11])
s = Base32Lower.encode(buf.toOpenArray(0, 9)) s = Base32Lower.encode(buf.toOpenArray(0, 9))
s.add(":") s.add(":")
s.add($nport) s.add($nport)
@ -244,14 +244,14 @@ proc onion3StB(s: string, vb: var VBuffer): bool =
address[36] = cast[byte](nport and 0xFF) address[36] = cast[byte](nport and 0xFF)
vb.writeArray(address) vb.writeArray(address)
result = true result = true
except: except CatchableError:
discard discard
proc onion3BtS(vb: var VBuffer, s: var string): bool = proc onion3BtS(vb: var VBuffer, s: var string): bool =
## ONION address bufferToString() implementation. ## ONION address bufferToString() implementation.
var buf: array[37, byte] var buf: array[37, byte]
if vb.readArray(buf) == 37: if vb.readArray(buf) == 37:
var nport = (cast[uint16](buf[35]) shl 8) or cast[uint16](buf[36]) var nport = (safeConvert[uint16](buf[35]) shl 8) or safeConvert[uint16](buf[36])
s = Base32Lower.encode(buf.toOpenArray(0, 34)) s = Base32Lower.encode(buf.toOpenArray(0, 34))
s.add(":") s.add(":")
s.add($nport) s.add($nport)

2
libp2p/multicodec.nim
View File

@ -19,8 +19,6 @@ import varint, vbuffer
import stew/results import stew/results
export results export results
{.deadCodeElim: on.}
## List of officially supported codecs can BE found here ## List of officially supported codecs can BE found here
## https://github.com/multiformats/multicodec/blob/master/table.csv ## https://github.com/multiformats/multicodec/blob/master/table.csv
const MultiCodecList = [ const MultiCodecList = [

2
libp2p/muxers/mplex/coder.nim
View File

@ -12,7 +12,7 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import pkg/[chronos, nimcrypto/utils, chronicles, stew/byteutils] import pkg/[chronos, chronicles, stew/byteutils]
import ../../stream/connection, import ../../stream/connection,
../../utility, ../../utility,
../../varint, ../../varint,

2
libp2p/muxers/mplex/lpchannel.nim
View File

@ -13,7 +13,7 @@ else:
{.push raises: [].} {.push raises: [].}
import std/[oids, strformat] import std/[oids, strformat]
import pkg/[chronos, chronicles, metrics, nimcrypto/utils] import pkg/[chronos, chronicles, metrics]
import ./coder, import ./coder,
../muxer, ../muxer,
../../stream/[bufferstream, connection, streamseq], ../../stream/[bufferstream, connection, streamseq],

3
libp2p/muxers/mplex/mplex.nim
View File

@ -203,7 +203,8 @@ method handle*(m: Mplex) {.async, gcsafe.} =
proc new*(M: type Mplex, proc new*(M: type Mplex,
conn: Connection, conn: Connection,
inTimeout, outTimeout: Duration = DefaultChanTimeout, inTimeout: Duration = DefaultChanTimeout,
outTimeout: Duration = DefaultChanTimeout,
maxChannCount: int = MaxChannelCount): Mplex = maxChannCount: int = MaxChannelCount): Mplex =
M(connection: conn, M(connection: conn,
inChannTimeout: inTimeout, inChannTimeout: inTimeout,

3
libp2p/muxers/muxer.nim
View File

@ -13,8 +13,7 @@ else:
{.push raises: [].} {.push raises: [].}
import chronos, chronicles import chronos, chronicles
import ../protocols/protocol, import ../stream/connection,
../stream/connection,
../errors ../errors
logScope: logScope:

2
libp2p/muxers/yamux/yamux.nim
View File

@ -84,7 +84,7 @@ proc `$`(header: YamuxHeader): string =
proc encode(header: YamuxHeader): array[12, byte] = proc encode(header: YamuxHeader): array[12, byte] =
result[0] = header.version result[0] = header.version
result[1] = uint8(header.msgType) result[1] = uint8(header.msgType)
result[2..3] = toBytesBE(cast[uint16](header.flags)) result[2..3] = toBytesBE(uint16(cast[uint8](header.flags))) # workaround https://github.com/nim-lang/Nim/issues/21789
result[4..7] = toBytesBE(header.streamId) result[4..7] = toBytesBE(header.streamId)
result[8..11] = toBytesBE(header.length) result[8..11] = toBytesBE(header.length)

24
libp2p/nameresolving/dnsresolver.nim
View File

@ -15,7 +15,8 @@ else:
import import
std/[streams, strutils, sets, sequtils], std/[streams, strutils, sets, sequtils],
chronos, chronicles, stew/byteutils, chronos, chronicles, stew/byteutils,
dnsclientpkg/[protocol, types] dnsclientpkg/[protocol, types],
../utility
import import
nameresolver nameresolver
@ -80,9 +81,7 @@ proc getDnsResponse(
# parseResponse can has a raises: [Exception, ..] because of # parseResponse can has a raises: [Exception, ..] because of
# https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008 # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
# it can't actually raise though # it can't actually raise though
return parseResponse(string.fromBytes(rawResponse)) return exceptionToAssert: parseResponse(string.fromBytes(rawResponse))
except CatchableError as exc: raise exc
except Exception as exc: raiseAssert exc.msg
finally: finally:
await sock.closeWait() await sock.closeWait()
@ -118,9 +117,7 @@ method resolveIp*(
# https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008 # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
# it can't actually raise though # it can't actually raise though
resolvedAddresses.incl( resolvedAddresses.incl(
try: answer.toString() exceptionToAssert(answer.toString())
except CatchableError as exc: raise exc
except Exception as exc: raiseAssert exc.msg
) )
except CancelledError as e: except CancelledError as e:
raise e raise e
@ -151,9 +148,13 @@ method resolveTxt*(
for _ in 0 ..< self.nameServers.len: for _ in 0 ..< self.nameServers.len:
let server = self.nameServers[0] let server = self.nameServers[0]
try: try:
# toString can has a raises: [Exception, ..] because of
# https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
# it can't actually raise though
let response = await getDnsResponse(server, address, TXT) let response = await getDnsResponse(server, address, TXT)
trace "Got TXT response", server = $server, answer=response.answers.mapIt(it.toString()) return exceptionToAssert:
return response.answers.mapIt(it.toString()) trace "Got TXT response", server = $server, answer=response.answers.mapIt(it.toString())
response.answers.mapIt(it.toString())
except CancelledError as e: except CancelledError as e:
raise e raise e
except CatchableError as e: except CatchableError as e:
@ -161,11 +162,6 @@ method resolveTxt*(
self.nameServers.add(self.nameServers[0]) self.nameServers.add(self.nameServers[0])
self.nameServers.delete(0) self.nameServers.delete(0)
continue continue
except Exception as e:
# toString can has a raises: [Exception, ..] because of
# https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
# it can't actually raise though
raiseAssert e.msg
debug "Failed to resolve TXT, returning empty set" debug "Failed to resolve TXT, returning empty set"
return @[] return @[]

2
libp2p/nameresolving/mockresolver.nim
View File

@ -13,7 +13,7 @@ else:
{.push raises: [].} {.push raises: [].}
import import
std/[streams, strutils, tables], std/tables,
chronos, chronicles chronos, chronicles
import nameresolver import nameresolver

2
libp2p/nameresolving/nameresolver.nim
View File

@ -16,7 +16,7 @@ import std/[sugar, sets, sequtils, strutils]
import import
chronos, chronos,
chronicles, chronicles,
stew/[endians2, byteutils] stew/endians2
import ".."/[multiaddress, multicodec] import ".."/[multiaddress, multicodec]
logScope: logScope:

2
libp2p/peerstore.nim
View File

@ -28,7 +28,7 @@ else:
import import
std/[tables, sets, options, macros], std/[tables, sets, options, macros],
chronos, chronicles, chronos,
./crypto/crypto, ./crypto/crypto,
./protocols/identify, ./protocols/identify,
./protocols/protocol, ./protocols/protocol,

12
libp2p/protobuf/minprotobuf.nim
View File

@ -72,12 +72,12 @@ type
hint | hint32 | hint64 | float32 | float64 hint | hint32 | hint64 | float32 | float64
const const
SupportedWireTypes* = { SupportedWireTypes* = @[
int(ProtoFieldKind.Varint), uint64(ProtoFieldKind.Varint),
int(ProtoFieldKind.Fixed64), uint64(ProtoFieldKind.Fixed64),
int(ProtoFieldKind.Length), uint64(ProtoFieldKind.Length),
int(ProtoFieldKind.Fixed32) uint64(ProtoFieldKind.Fixed32)
} ]
template checkFieldNumber*(i: int) = template checkFieldNumber*(i: int) =
doAssert((i > 0 and i < (1 shl 29)) and not(i >= 19000 and i <= 19999), doAssert((i > 0 and i < (1 shl 29)) and not(i >= 19000 and i <= 19999),

6
libp2p/protocols/connectivity/autonat/client.nim
View File

@ -12,8 +12,8 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import std/[options, sets, sequtils] import std/options
import stew/[results, objects] import stew/results
import chronos, chronicles import chronos, chronicles
import ../../../switch, import ../../../switch,
../../../multiaddress, ../../../multiaddress,
@ -36,7 +36,7 @@ proc sendDial(conn: Connection, pid: PeerId, addrs: seq[MultiAddress]) {.async.}
method dialMe*(self: AutonatClient, switch: Switch, pid: PeerId, addrs: seq[MultiAddress] = newSeq[MultiAddress]()): method dialMe*(self: AutonatClient, switch: Switch, pid: PeerId, addrs: seq[MultiAddress] = newSeq[MultiAddress]()):
Future[MultiAddress] {.base, async.} = Future[MultiAddress] {.base, async.} =
proc getResponseOrRaise(autonatMsg: Option[AutonatMsg]): AutonatDialResponse {.raises: [UnpackError, AutonatError].} = proc getResponseOrRaise(autonatMsg: Option[AutonatMsg]): AutonatDialResponse {.raises: [Defect, AutonatError].} =
if autonatMsg.isNone() or if autonatMsg.isNone() or
autonatMsg.get().msgType != DialResponse or autonatMsg.get().msgType != DialResponse or
autonatMsg.get().response.isNone() or autonatMsg.get().response.isNone() or

2
libp2p/protocols/connectivity/autonat/core.nim
View File

@ -12,7 +12,7 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import std/[options, sets, sequtils] import std/[options]
import stew/[results, objects] import stew/[results, objects]
import chronos, chronicles import chronos, chronicles
import ../../../multiaddress, import ../../../multiaddress,

2
libp2p/protocols/connectivity/autonat/server.nim
View File

@ -14,7 +14,7 @@ else:
import std/[options, sets, sequtils] import std/[options, sets, sequtils]
import stew/results import stew/results
import chronos, chronicles, stew/objects import chronos, chronicles
import ../../protocol, import ../../protocol,
../../../switch, ../../../switch,
../../../multiaddress, ../../../multiaddress,

17
libp2p/protocols/connectivity/relay/messages.nim
View File

@ -12,7 +12,7 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import options, macros, sequtils import options, macros
import stew/objects import stew/objects
import ../../../peerinfo, import ../../../peerinfo,
../../../signed_envelope ../../../signed_envelope
@ -115,9 +115,10 @@ proc decode*(_: typedesc[RelayMessage], buf: seq[byte]): Option[RelayMessage] =
if r2.get(): rMsg.srcPeer = some(src) if r2.get(): rMsg.srcPeer = some(src)
if r3.get(): rMsg.dstPeer = some(dst) if r3.get(): rMsg.dstPeer = some(dst)
if r4.get(): if r4.get():
if statusOrd.int notin StatusV1: var status: StatusV1
if not checkedEnumAssign(status, statusOrd):
return none(RelayMessage) return none(RelayMessage)
rMsg.status = some(StatusV1(statusOrd)) rMsg.status = some(status)
some(rMsg) some(rMsg)
# Voucher # Voucher
@ -285,9 +286,10 @@ proc decode*(_: typedesc[HopMessage], buf: seq[byte]): Option[HopMessage] =
if r3.get(): msg.reservation = some(reservation) if r3.get(): msg.reservation = some(reservation)
if r4.get(): msg.limit = limit if r4.get(): msg.limit = limit
if r5.get(): if r5.get():
if statusOrd.int notin StatusV2: var status: StatusV2
if not checkedEnumAssign(status, statusOrd):
return none(HopMessage) return none(HopMessage)
msg.status = some(StatusV2(statusOrd)) msg.status = some(status)
some(msg) some(msg)
# Circuit Relay V2 Stop Message # Circuit Relay V2 Stop Message
@ -364,7 +366,8 @@ proc decode*(_: typedesc[StopMessage], buf: seq[byte]): Option[StopMessage] =
if r2.get(): msg.peer = some(peer) if r2.get(): msg.peer = some(peer)
if r3.get(): msg.limit = limit if r3.get(): msg.limit = limit
if r4.get(): if r4.get():
if statusOrd.int notin StatusV2: var status: StatusV2
if not checkedEnumAssign(status, statusOrd):
return none(StopMessage) return none(StopMessage)
msg.status = some(StatusV2(statusOrd)) msg.status = some(status)
some(msg) some(msg)

3
libp2p/protocols/connectivity/relay/relay.nim
View File

@ -12,7 +12,7 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import options, sequtils, tables, sugar import options, sequtils, tables
import chronos, chronicles import chronos, chronicles
@ -25,7 +25,6 @@ import ./messages,
../../../multicodec, ../../../multicodec,
../../../stream/connection, ../../../stream/connection,
../../../protocols/protocol, ../../../protocols/protocol,
../../../transports/transport,
../../../errors, ../../../errors,
../../../utils/heartbeat, ../../../utils/heartbeat,
../../../signed_envelope ../../../signed_envelope

2
libp2p/protocols/ping.nim
View File

@ -15,7 +15,7 @@ else:
{.push raises: [].} {.push raises: [].}
import chronos, chronicles import chronos, chronicles
import bearssl/[rand, hash] import bearssl/rand
import ../protobuf/minprotobuf, import ../protobuf/minprotobuf,
../peerinfo, ../peerinfo,
../stream/connection, ../stream/connection,

2
libp2p/protocols/pubsub/gossipsub/behavior.nim
View File

@ -15,7 +15,7 @@ else:
import std/[tables, sequtils, sets, algorithm, deques] import std/[tables, sequtils, sets, algorithm, deques]
import chronos, chronicles, metrics import chronos, chronicles, metrics
import "."/[types, scoring] import "."/[types, scoring]
import ".."/[pubsubpeer, peertable, timedcache, mcache, floodsub, pubsub] import ".."/[pubsubpeer, peertable, mcache, floodsub, pubsub]
import "../rpc"/[messages] import "../rpc"/[messages]
import "../../.."/[peerid, multiaddress, utility, switch, routing_record, signed_envelope, utils/heartbeat] import "../../.."/[peerid, multiaddress, utility, switch, routing_record, signed_envelope, utils/heartbeat]

4
libp2p/protocols/pubsub/gossipsub/scoring.nim
View File

@ -16,7 +16,7 @@ import std/[tables, sets, options]
import chronos, chronicles, metrics import chronos, chronicles, metrics
import "."/[types] import "."/[types]
import ".."/[pubsubpeer] import ".."/[pubsubpeer]
import "../../.."/[peerid, multiaddress, utility, switch, utils/heartbeat] import "../../.."/[peerid, multiaddress, switch, utils/heartbeat]
logScope: logScope:
topics = "libp2p gossipsub" topics = "libp2p gossipsub"
@ -250,7 +250,7 @@ proc updateScores*(g: GossipSub) = # avoid async
if g.parameters.disconnectBadPeers and stats.score < g.parameters.graylistThreshold and if g.parameters.disconnectBadPeers and stats.score < g.parameters.graylistThreshold and
peer.peerId notin g.parameters.directPeers: peer.peerId notin g.parameters.directPeers:
debug "disconnecting bad score peer", peer, score = peer.score debug "disconnecting bad score peer", peer, score = peer.score
asyncSpawn(try: g.disconnectPeer(peer) except Exception as exc: raiseAssert exc.msg) asyncSpawn(g.disconnectPeer(peer))
libp2p_gossipsub_peers_scores.inc(peer.score, labelValues = [agent]) libp2p_gossipsub_peers_scores.inc(peer.score, labelValues = [agent])

1
libp2p/protocols/pubsub/rpc/message.nim
View File

@ -12,7 +12,6 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import hashes
import chronicles, metrics, stew/[byteutils, endians2] import chronicles, metrics, stew/[byteutils, endians2]
import ./messages, import ./messages,
./protobuf, ./protobuf,

2
libp2p/protocols/secure/noise.nim
View File

@ -12,7 +12,7 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import std/[oids, strformat] import std/strformat
import chronos import chronos
import chronicles import chronicles
import bearssl/[rand, hash] import bearssl/[rand, hash]

2
libp2p/services/autorelayservice.nim
View File

@ -12,7 +12,7 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import chronos, chronicles, times, tables, sequtils, options import chronos, chronicles, times, tables, sequtils
import ../switch, import ../switch,
../protocols/connectivity/relay/[client, utils] ../protocols/connectivity/relay/[client, utils]

3
libp2p/stream/bufferstream.nim
View File

@ -18,9 +18,6 @@ import chronos, chronicles, metrics
import ../stream/connection import ../stream/connection
import ./streamseq import ./streamseq
when chronicles.enabledLogLevel == LogLevel.TRACE:
import oids
export connection export connection
logScope: logScope:

2
libp2p/stream/chronosstream.nim
View File

@ -12,7 +12,7 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import std/[oids, strformat] import std/[strformat]
import stew/results import stew/results
import chronos, chronicles, metrics import chronos, chronicles, metrics
import connection import connection

8
libp2p/switch.nim
View File

@ -20,9 +20,7 @@ import std/[tables,
options, options,
sequtils, sequtils,
sets, sets,
oids, oids]
sugar,
math]
import chronos, import chronos,
chronicles, chronicles,
@ -30,14 +28,12 @@ import chronos,
import stream/connection, import stream/connection,
transports/transport, transports/transport,
upgrademngrs/[upgrade, muxedupgrade], upgrademngrs/upgrade,
multistream, multistream,
multiaddress, multiaddress,
protocols/protocol, protocols/protocol,
protocols/secure/secure, protocols/secure/secure,
peerinfo, peerinfo,
protocols/identify,
muxers/muxer,
utils/semaphore, utils/semaphore,
connmanager, connmanager,
nameresolving/nameresolver, nameresolving/nameresolver,

3
libp2p/transports/tcptransport.nim
View File

@ -14,14 +14,13 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import std/[oids, sequtils] import std/[sequtils]
import stew/results import stew/results
import chronos, chronicles import chronos, chronicles
import transport, import transport,
../errors, ../errors,
../wire, ../wire,
../multicodec, ../multicodec,
../multistream,
../connmanager, ../connmanager,
../multiaddress, ../multiaddress,
../stream/connection, ../stream/connection,

2
libp2p/upgrademngrs/muxedupgrade.nim
View File

@ -12,7 +12,7 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import std/[tables, sequtils] import std/sequtils
import pkg/[chronos, chronicles, metrics] import pkg/[chronos, chronicles, metrics]
import ../upgrademngrs/upgrade, import ../upgrademngrs/upgrade,

3
libp2p/upgrademngrs/upgrade.nim
View File

@ -13,7 +13,7 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import std/[options, sequtils, strutils] import std/[sequtils, strutils]
import pkg/[chronos, chronicles, metrics] import pkg/[chronos, chronicles, metrics]
import ../stream/connection, import ../stream/connection,
@ -21,7 +21,6 @@ import ../stream/connection,
../protocols/identify, ../protocols/identify,
../muxers/muxer, ../muxers/muxer,
../multistream, ../multistream,
../peerstore,
../connmanager, ../connmanager,
../errors, ../errors,
../utility ../utility

21
libp2p/utility.nim
View File

@ -65,3 +65,24 @@ when defined(libp2p_agents_metrics):
const const
KnownLibP2PAgents* {.strdefine.} = "nim-libp2p" KnownLibP2PAgents* {.strdefine.} = "nim-libp2p"
KnownLibP2PAgentsSeq* = KnownLibP2PAgents.safeToLowerAscii().tryGet().split(",") KnownLibP2PAgentsSeq* = KnownLibP2PAgents.safeToLowerAscii().tryGet().split(",")
template safeConvert*[T: SomeInteger, S: Ordinal](value: S): T =
## Converts `value` from S to `T` iff `value` is guaranteed to be preserved.
when int64(T.low) <= int64(S.low()) and uint64(T.high) >= uint64(S.high):
T(value)
else:
{.error: "Source and target types have an incompatible range low..high".}
template exceptionToAssert*(body: untyped): untyped =
block:
var res: type(body)
when defined(nimHasWarnBareExcept):
{.push warning[BareExcept]:off.}
try:
res = body
except CatchableError as exc: raise exc
except Defect as exc: raise exc
except Exception as exc: raiseAssert exc.msg
when defined(nimHasWarnBareExcept):
{.pop.}
res

1
libp2p/utils/heartbeat.nim
View File

@ -12,7 +12,6 @@ when (NimMajor, NimMinor) < (1, 4):
else: else:
{.push raises: [].} {.push raises: [].}
import sequtils
import chronos, chronicles import chronos, chronicles
export chronicles export chronicles

4
tests/commontransport.nim
View File

@ -1,13 +1,11 @@
{.used.} {.used.}
import sequtils
import chronos, stew/[byteutils, results] import chronos, stew/[byteutils, results]
import ../libp2p/[stream/connection, import ../libp2p/[stream/connection,
transports/transport, transports/transport,
upgrademngrs/upgrade, upgrademngrs/upgrade,
multiaddress, multiaddress,
errors, errors]
wire]
import ./helpers import ./helpers

7
tests/helpers.nim
View File

@ -56,9 +56,14 @@ template checkTrackers*() =
checkpoint tracker.dump() checkpoint tracker.dump()
fail() fail()
# Also test the GC is not fooling with us # Also test the GC is not fooling with us
when defined(nimHasWarnBareExcept):
{.push warning[BareExcept]:off.}
try: try:
GC_fullCollect() GC_fullCollect()
except: discard except:
discard
when defined(nimHasWarnBareExcept):
{.pop.}
type RngWrap = object type RngWrap = object
rng: ref HmacDrbgContext rng: ref HmacDrbgContext

11
tests/testautonat.nim
View File

@ -1,3 +1,14 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import std/options import std/options
import chronos import chronos
import import

4
tests/testautonatservice.nim
View File

@ -1,4 +1,6 @@
# Nim-LibP2P {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE)) # * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))

12
tests/testautorelay.nim
View File

@ -1,15 +1,21 @@
{.used.} {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import chronos, options import chronos, options
import ../libp2p import ../libp2p
import ../libp2p/[crypto/crypto, import ../libp2p/[crypto/crypto,
protocols/connectivity/relay/relay, protocols/connectivity/relay/relay,
protocols/connectivity/relay/messages,
protocols/connectivity/relay/utils,
protocols/connectivity/relay/client, protocols/connectivity/relay/client,
services/autorelayservice] services/autorelayservice]
import ./helpers import ./helpers
import stew/byteutils
proc createSwitch(r: Relay, autorelay: Service = nil): Switch = proc createSwitch(r: Relay, autorelay: Service = nil): Switch =
var builder = SwitchBuilder.new() var builder = SwitchBuilder.new()

13
tests/testbufferstream.nim
View File

@ -1,3 +1,14 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import chronos, stew/byteutils import chronos, stew/byteutils
import ../libp2p/stream/bufferstream, import ../libp2p/stream/bufferstream,
../libp2p/stream/lpstream, ../libp2p/stream/lpstream,
@ -5,8 +16,6 @@ import ../libp2p/stream/bufferstream,
import ./helpers import ./helpers
{.used.}
suite "BufferStream": suite "BufferStream":
teardown: teardown:
# echo getTracker(BufferStreamTrackerName).dump() # echo getTracker(BufferStreamTrackerName).dump()

13
tests/testcid.nim
View File

@ -1,8 +1,17 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import unittest2 import unittest2
import ../libp2p/[cid, multihash, multicodec] import ../libp2p/[cid, multihash, multicodec]
when defined(nimHasUsed): {.used.}
suite "Content identifier CID test suite": suite "Content identifier CID test suite":
test "CIDv0 test vector": test "CIDv0 test vector":

13
tests/testconnection.nim
View File

@ -1,4 +1,15 @@
import chronos, nimcrypto/utils {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import chronos
import ../libp2p/[stream/connection, import ../libp2p/[stream/connection,
stream/bufferstream] stream/bufferstream]

11
tests/testconnmngr.nim
View File

@ -1,3 +1,14 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import std/[sequtils,tables] import std/[sequtils,tables]
import stew/results import stew/results
import chronos import chronos

6
tests/testcrypto.nim
View File

@ -1,3 +1,5 @@
{.used.}
# Nim-Libp2p # Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of
@ -11,11 +13,9 @@
## https://github.com/libp2p/go-libp2p-crypto/blob/master/key.go ## https://github.com/libp2p/go-libp2p-crypto/blob/master/key.go
import unittest2 import unittest2
import bearssl/hash import bearssl/hash
import nimcrypto/[utils, sysrand] import nimcrypto/utils
import ../libp2p/crypto/[crypto, chacha20poly1305, curve25519, hkdf] import ../libp2p/crypto/[crypto, chacha20poly1305, curve25519, hkdf]
when defined(nimHasUsed): {.used.}
const const
PrivateKeys = [ PrivateKeys = [
"""080012A809308204A40201000282010100C8B014EC01E135D635F7E246BA7D42 """080012A809308204A40201000282010100C8B014EC01E135D635F7E246BA7D42

4
tests/testdcutr.nim
View File

@ -1,4 +1,6 @@
# Nim-LibP2P {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE)) # * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))

10
tests/testdiscovery.nim
View File

@ -1,7 +1,15 @@
{.used.} {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import options, chronos, sets import options, chronos, sets
import stew/byteutils
import ../libp2p/[protocols/rendezvous, import ../libp2p/[protocols/rendezvous,
switch, switch,
builders, builders,

5
tests/testecnist.nim
View File

@ -1,3 +1,5 @@
{.used.}
# Nim-Libp2p # Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of
@ -6,13 +8,12 @@
# at your option. # at your option.
# This file may not be copied, modified, or distributed except according to # This file may not be copied, modified, or distributed except according to
# those terms. # those terms.
import unittest2 import unittest2
import nimcrypto/utils import nimcrypto/utils
import ../libp2p/crypto/[crypto, ecnist] import ../libp2p/crypto/[crypto, ecnist]
import stew/results import stew/results
when defined(nimHasUsed): {.used.}
const const
TestsCount = 10 # number of random tests TestsCount = 10 # number of random tests

4
tests/tested25519.nim
View File

@ -1,3 +1,5 @@
{.used.}
# Nim-Libp2p # Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of
@ -13,8 +15,6 @@ import nimcrypto/utils
import ../libp2p/crypto/crypto import ../libp2p/crypto/crypto
import ../libp2p/crypto/ed25519/ed25519 import ../libp2p/crypto/ed25519/ed25519
when defined(nimHasUsed): {.used.}
const TestsCount = 20 const TestsCount = 20
const SecretKeys = [ const SecretKeys = [

2
tests/testfuture.nim
View File

@ -1,3 +1,5 @@
{.used.}
# Nim-Libp2p # Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of

17
tests/testheartbeat.nim
View File

@ -1,11 +1,22 @@
import chronos {.used.}
import ../libp2p/utils/heartbeat # Nim-Libp2p
import ./helpers # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
# MacOs has some nasty jitter when sleeping # MacOs has some nasty jitter when sleeping
# (up to 7 ms), so we skip test there # (up to 7 ms), so we skip test there
when not defined(macosx): when not defined(macosx):
import chronos
import ../libp2p/utils/heartbeat
import ./helpers
suite "Heartbeat": suite "Heartbeat":
asyncTest "simple heartbeat": asyncTest "simple heartbeat":

15
tests/testidentify.nim
View File

@ -1,5 +1,16 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import options import options
import chronos, strutils, sequtils, sets, algorithm import chronos
import ../libp2p/[protocols/identify, import ../libp2p/[protocols/identify,
multiaddress, multiaddress,
peerinfo, peerinfo,
@ -14,8 +25,6 @@ import ../libp2p/[protocols/identify,
upgrademngrs/upgrade] upgrademngrs/upgrade]
import ./helpers import ./helpers
when defined(nimHasUsed): {.used.}
suite "Identify": suite "Identify":
teardown: teardown:
checkTrackers() checkTrackers()

5
tests/testminasn1.nim
View File

@ -1,3 +1,5 @@
{.used.}
# Nim-Libp2p # Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of
@ -6,12 +8,11 @@
# at your option. # at your option.
# This file may not be copied, modified, or distributed except according to # This file may not be copied, modified, or distributed except according to
# those terms. # those terms.
import unittest2 import unittest2
import ../libp2p/crypto/minasn1 import ../libp2p/crypto/minasn1
import nimcrypto/utils as ncrutils import nimcrypto/utils as ncrutils
when defined(nimHasUsed): {.used.}
const Asn1EdgeValues = [ const Asn1EdgeValues = [
0'u64, (1'u64 shl 7) - 1'u64, 0'u64, (1'u64 shl 7) - 1'u64,
(1'u64 shl 7), (1'u64 shl 8) - 1'u64, (1'u64 shl 7), (1'u64 shl 8) - 1'u64,

4
tests/testminprotobuf.nim
View File

@ -1,3 +1,5 @@
{.used.}
# Nim-Libp2p # Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of
@ -11,8 +13,6 @@ import unittest2
import ../libp2p/protobuf/minprotobuf import ../libp2p/protobuf/minprotobuf
import stew/byteutils, strutils import stew/byteutils, strutils
when defined(nimHasUsed): {.used.}
suite "MinProtobuf test suite": suite "MinProtobuf test suite":
const VarintVectors = [ const VarintVectors = [
"0800", "0801", "08ffffffff07", "08ffffffff0f", "08ffffffffffffffff7f", "0800", "0801", "08ffffffff07", "08ffffffff0f", "08ffffffffffffffff7f",

15
tests/testmplex.nim
View File

@ -1,4 +1,15 @@
import strformat, random, oids, sequtils {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import strformat, random, sequtils
import chronos, nimcrypto/utils, chronicles, stew/byteutils import chronos, nimcrypto/utils, chronicles, stew/byteutils
import ../libp2p/[errors, import ../libp2p/[errors,
stream/connection, stream/connection,
@ -15,8 +26,6 @@ import ../libp2p/[errors,
import ./helpers import ./helpers
{.used.}
suite "Mplex": suite "Mplex":
teardown: teardown:
checkTrackers() checkTrackers()

13
tests/testmultiaddress.nim
View File

@ -1,4 +1,6 @@
# Nim-LibP2P {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE)) # * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
@ -18,8 +20,6 @@ import unittest2
import stew/byteutils import stew/byteutils
import ../libp2p/[multicodec, multiaddress] import ../libp2p/[multicodec, multiaddress]
when defined(nimHasUsed): {.used.}
type type
PatternVector = object PatternVector = object
pattern: MaPattern pattern: MaPattern
@ -329,12 +329,7 @@ suite "MultiAddress test suite":
test "rust-multiaddr failure test vectors": test "rust-multiaddr failure test vectors":
for item in RustFailureVectors: for item in RustFailureVectors:
var r = false check MultiAddress.init(item).isErr()
try:
discard MultiAddress.init(item).get()
except:
r = true
check r == true
test "Concatenation test": test "Concatenation test":
var ma1 = MultiAddress.init() var ma1 = MultiAddress.init()

13
tests/testmultibase.nim
View File

@ -1,9 +1,18 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import unittest2 import unittest2
import ../libp2p/multibase import ../libp2p/multibase
import stew/results import stew/results
when defined(nimHasUsed): {.used.}
const GoTestVectors = [ const GoTestVectors = [
[ [
"identity", "identity",

13
tests/testmultihash.nim
View File

@ -1,9 +1,18 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import unittest2 import unittest2
import nimcrypto/utils import nimcrypto/utils
import ../libp2p/multihash import ../libp2p/multihash
when defined(nimHasUsed): {.used.}
const const
RustTestVectors = [ RustTestVectors = [
[ [

16
tests/testmultistream.nim
View File

@ -1,7 +1,17 @@
import strutils, strformat, stew/byteutils {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import strformat, stew/byteutils
import chronos import chronos
import ../libp2p/errors, import ../libp2p/multistream,
../libp2p/multistream,
../libp2p/stream/bufferstream, ../libp2p/stream/bufferstream,
../libp2p/stream/connection, ../libp2p/stream/connection,
../libp2p/multiaddress, ../libp2p/multiaddress,

22
tests/testnameresolve.nim
View File

@ -1,17 +1,23 @@
{.used.} {.used.}
import std/[streams, strutils, sets, sequtils, tables, algorithm] # Nim-Libp2p
import chronos, stew/byteutils # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import std/[strutils, sequtils, tables]
import chronos
import ../libp2p/[stream/connection, import ../libp2p/[stream/connection,
transports/transport,
transports/tcptransport, transports/tcptransport,
upgrademngrs/upgrade, upgrademngrs/upgrade,
multiaddress, multiaddress,
errors,
nameresolving/nameresolver, nameresolving/nameresolver,
nameresolving/dnsresolver, nameresolving/dnsresolver,
nameresolving/mockresolver, nameresolving/mockresolver]
wire]
import ./helpers import ./helpers
# #
@ -41,8 +47,8 @@ proc guessOsNameServers(): seq[TransportAddress] =
resultSeq.add(initTAddress(lineParsed[1], Port(53))) resultSeq.add(initTAddress(lineParsed[1], Port(53)))
if resultSeq.len > 2: break #3 nameserver max on linux if resultSeq.len > 2: break #3 nameserver max on linux
except Exception as e: except CatchableError as err:
echo "Failed to get unix nameservers ", e.msg echo "Failed to get unix nameservers ", err.msg
finally: finally:
if resultSeq.len > 0: if resultSeq.len > 0:
return resultSeq return resultSeq

14
tests/testnative.nim
View File

@ -1,3 +1,14 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import testvarint, import testvarint,
testconnection, testconnection,
testminprotobuf, testminprotobuf,
@ -45,4 +56,5 @@ import testtcptransport,
testautonatservice, testautonatservice,
testautorelay, testautorelay,
testdcutr, testdcutr,
testhpservice testhpservice,
testutility

7
tests/testnoise.nim
View File

@ -1,4 +1,6 @@
# Nim-LibP2P {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE)) # * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
@ -7,9 +9,6 @@
# This file may not be copied, modified, or distributed except according to # This file may not be copied, modified, or distributed except according to
# those terms. # those terms.
{.used.}
import tables
import chronos, stew/byteutils import chronos, stew/byteutils
import chronicles import chronicles
import ../libp2p/[switch, import ../libp2p/[switch,

11
tests/testobservedaddrmanager.nim
View File

@ -1,3 +1,14 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import unittest2, import unittest2,
../libp2p/multiaddress, ../libp2p/multiaddress,
../libp2p/observedaddrmanager, ../libp2p/observedaddrmanager,

3
tests/testpeerid.nim
View File

@ -1,3 +1,5 @@
{.used.}
# Nim-Libp2p # Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of
@ -13,7 +15,6 @@ import unittest2
import nimcrypto/utils, stew/base58 import nimcrypto/utils, stew/base58
import ../libp2p/crypto/crypto, ../libp2p/peerid import ../libp2p/crypto/crypto, ../libp2p/peerid
import bearssl/hash import bearssl/hash
when defined(nimHasUsed): {.used.}
const const
# Test vectors are generated using # Test vectors are generated using

11
tests/testpeerinfo.nim
View File

@ -1,7 +1,16 @@
{.used.} {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import options import options
import chronos, stew/byteutils import chronos
import ../libp2p/crypto/crypto, import ../libp2p/crypto/crypto,
../libp2p/multicodec, ../libp2p/multicodec,
../libp2p/peerinfo, ../libp2p/peerinfo,

13
tests/testpeerstore.nim
View File

@ -1,6 +1,17 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import import
unittest2, unittest2,
std/[tables, sequtils, sets], std/[tables, sequtils],
../libp2p/crypto/crypto, ../libp2p/crypto/crypto,
../libp2p/multiaddress, ../libp2p/multiaddress,
../libp2p/peerid, ../libp2p/peerid,

20
tests/testping.nim
View File

@ -1,10 +1,18 @@
import options {.used.}
import chronos, strutils
import ../libp2p/[protocols/identify, # Nim-Libp2p
protocols/ping, # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import chronos
import ../libp2p/[protocols/ping,
multiaddress, multiaddress,
peerinfo, peerinfo,
wire,
peerid, peerid,
stream/connection, stream/connection,
multistream, multistream,
@ -14,8 +22,6 @@ import ../libp2p/[protocols/identify,
upgrademngrs/upgrade] upgrademngrs/upgrade]
import ./helpers import ./helpers
when defined(nimHasUsed): {.used.}
suite "Ping": suite "Ping":
var var
ma {.threadvar.}: MultiAddress ma {.threadvar.}: MultiAddress

10
tests/testrelayv1.nim
View File

@ -1,5 +1,14 @@
{.used.} {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import options, bearssl, chronos import options, bearssl, chronos
import stew/byteutils import stew/byteutils
import ../libp2p/[protocols/connectivity/relay/relay, import ../libp2p/[protocols/connectivity/relay/relay,
@ -12,7 +21,6 @@ import ../libp2p/[protocols/connectivity/relay/relay,
peerid, peerid,
stream/connection, stream/connection,
multistream, multistream,
transports/transport,
switch, switch,
builders, builders,
upgrademngrs/upgrade, upgrademngrs/upgrade,

9
tests/testrelayv2.nim
View File

@ -1,5 +1,14 @@
{.used.} {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import bearssl, chronos, options import bearssl, chronos, options
import ../libp2p import ../libp2p
import ../libp2p/[protocols/connectivity/relay/relay, import ../libp2p/[protocols/connectivity/relay/relay,

13
tests/testrendezvous.nim
View File

@ -1,7 +1,16 @@
{.used.} {.used.}
import options, sequtils, strutils # Nim-Libp2p
import stew/byteutils, chronos # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import sequtils, strutils
import chronos
import ../libp2p/[protocols/rendezvous, import ../libp2p/[protocols/rendezvous,
switch, switch,
builders,] builders,]

11
tests/testrouting_record.nim
View File

@ -1,3 +1,14 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import unittest2 import unittest2
import stew/byteutils import stew/byteutils
import ../libp2p/[routing_record, crypto/crypto] import ../libp2p/[routing_record, crypto/crypto]

5
tests/testrsa.nim
View File

@ -1,3 +1,5 @@
{.used.}
# Nim-Libp2p # Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of
@ -6,12 +8,11 @@
# at your option. # at your option.
# This file may not be copied, modified, or distributed except according to # This file may not be copied, modified, or distributed except according to
# those terms. # those terms.
import unittest2 import unittest2
import nimcrypto/utils import nimcrypto/utils
import ../libp2p/crypto/[crypto, rsa] import ../libp2p/crypto/[crypto, rsa]
when defined(nimHasUsed): {.used.}
const const
NotAllowedPrivateKeys = [ NotAllowedPrivateKeys = [
"""3082013902010002410093405660EDBF5DADAF93DD91E1B38F1EF086A3A0C6EA """3082013902010002410093405660EDBF5DADAF93DD91E1B38F1EF086A3A0C6EA

6
tests/testsecp256k1.nim
View File

@ -1,3 +1,5 @@
{.used.}
# Nim-Libp2p # Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH # Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of # Licensed under either of
@ -6,11 +8,9 @@
# at your option. # at your option.
# This file may not be copied, modified, or distributed except according to # This file may not be copied, modified, or distributed except according to
# those terms. # those terms.
import unittest2 import unittest2
import ../libp2p/crypto/[crypto, secp] import ../libp2p/crypto/[crypto, secp]
import nimcrypto/utils
when defined(nimHasUsed): {.used.}
let rng = newRng() let rng = newRng()

11
tests/testsemaphore.nim
View File

@ -1,3 +1,14 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import random import random
import chronos import chronos

11
tests/testsigned_envelope.nim
View File

@ -1,3 +1,14 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import unittest2 import unittest2
import stew/byteutils import stew/byteutils
import ../libp2p/[signed_envelope] import ../libp2p/[signed_envelope]

9
tests/teststreamseq.nim
View File

@ -1,5 +1,14 @@
{.used.} {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import unittest2 import unittest2
import stew/byteutils import stew/byteutils
import ../libp2p/stream/streamseq import ../libp2p/stream/streamseq

13
tests/testswitch.nim
View File

@ -1,9 +1,17 @@
{.used.} {.used.}
import options, sequtils, sets # Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import options, sequtils
import chronos import chronos
import stew/byteutils import stew/byteutils
import nimcrypto/sysrand
import ../libp2p/[errors, import ../libp2p/[errors,
switch, switch,
multistream, multistream,
@ -19,7 +27,6 @@ import ../libp2p/[errors,
muxers/muxer, muxers/muxer,
muxers/mplex/lpchannel, muxers/mplex/lpchannel,
stream/lpstream, stream/lpstream,
nameresolving/nameresolver,
nameresolving/mockresolver, nameresolving/mockresolver,
stream/chronosstream, stream/chronosstream,
utils/semaphore, utils/semaphore,

10
tests/testtcptransport.nim
View File

@ -1,6 +1,14 @@
{.used.} {.used.}
import sequtils # Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import chronos, stew/byteutils import chronos, stew/byteutils
import ../libp2p/[stream/connection, import ../libp2p/[stream/connection,
transports/transport, transports/transport,

9
tests/testtortransport.nim
View File

@ -1,5 +1,14 @@
{.used.} {.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
when (NimMajor, NimMinor) < (1, 4): when (NimMajor, NimMinor) < (1, 4):
{.push raises: [Defect].} {.push raises: [Defect].}
else: else:

76
tests/testutility.nim Normal file
View File

@ -0,0 +1,76 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import strformat
import ./helpers
import ../libp2p/utility
suite "Utility":
test "successful safeConvert from int8 to int16":
var result: int16 = safeConvert[int16, int8](-128)
assert result == -128, fmt"Expected -128 but got {result}"
test "unsuccessful safeConvert from int16 to int8":
doAssert not (compiles do:
var result: int8 = safeConvert[int8, int16](32767))
test "successful safeConvert from uint8 to uint16":
var result: uint16 = safeConvert[uint16, uint8](255)
assert result == 255, fmt"Expected 255 but got {result}"
test "unsuccessful safeConvert from uint16 to uint8":
doAssert not (compiles do:
var result: uint8 = safeConvert[uint8, uint16](256))
test "successful safeConvert from char to int":
var result: int = safeConvert[int, char]('A')
assert result == 65, fmt"Expected 65 but got {result}"
test "unsuccessful safeConvert from int to char":
doAssert not (compiles do:
var result: char = safeConvert[char, int](128))
test "successful safeConvert from bool to int":
var result: int = safeConvert[int, bool](true)
assert result == 1, fmt"Expected 1 but got {result}"
test "unsuccessful safeConvert from int to bool":
doAssert not (compiles do:
var result: bool = safeConvert[bool, int](2))
test "successful safeConvert from enum to int":
type Color = enum red, green, blue
var result: int = safeConvert[int, Color](green)
assert result == 1, fmt"Expected 1 but got {result}"
test "unsuccessful safeConvert from int to enum":
type Color = enum red, green, blue
doAssert not (compiles do:
var result: Color = safeConvert[Color, int](3))
test "successful safeConvert from range to int":
var result: int = safeConvert[int, range[1..10]](5)
assert result == 5, fmt"Expected 5 but got {result}"
test "unsuccessful safeConvert from int to range":
doAssert not (compiles do:
var result: range[1..10] = safeConvert[range[1..10], int](11))
test "unsuccessful safeConvert from int to uint":
doAssert not (compiles do:
var result: uint = safeConvert[uint, int](11))
test "unsuccessful safeConvert from uint to int":
doAssert not (compiles do:
var result: uint = safeConvert[int, uint](11))

13
tests/testvarint.nim
View File

@ -1,8 +1,17 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import unittest2 import unittest2
import ../libp2p/varint import ../libp2p/varint
when defined(nimHasUsed): {.used.}
const PBedgeValues = [ const PBedgeValues = [
0'u64, (1'u64 shl 7) - 1'u64, 0'u64, (1'u64 shl 7) - 1'u64,
(1'u64 shl 7), (1'u64 shl 14) - 1'u64, (1'u64 shl 7), (1'u64 shl 14) - 1'u64,

16
tests/testwstransport.nim
View File

@ -1,14 +1,21 @@
{.used.} {.used.}
import sequtils # Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import chronos, stew/byteutils import chronos, stew/byteutils
import ../libp2p/[stream/connection, import ../libp2p/[stream/connection,
transports/transport, transports/transport,
transports/wstransport, transports/wstransport,
upgrademngrs/upgrade, upgrademngrs/upgrade,
multiaddress, multiaddress,
errors, errors]
wire]
import ./helpers, ./commontransport import ./helpers, ./commontransport
@ -68,7 +75,8 @@ suite "WebSocket transport":
TLSPrivateKey.init(SecureKey), TLSPrivateKey.init(SecureKey),
TLSCertificate.init(SecureCert), TLSCertificate.init(SecureCert),
{TLSFlags.NoVerifyHost, TLSFlags.NoVerifyServerName}) {TLSFlags.NoVerifyHost, TLSFlags.NoVerifyServerName})
except Exception: check(false) except CatchableError:
check(false)
commonTransportTest( commonTransportTest(
wsSecureTranspProvider, wsSecureTranspProvider,

11
tests/testyamux.nim
View File

@ -1,3 +1,14 @@
{.used.}
# Nim-Libp2p
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import sugar import sugar
import chronos import chronos
import import