17283659198

Committed 28 Aug 2025 02:05AM UTC coverage: 93.75% (+1.7%) from 92.046%

Build # 17283659198

Build Type

push

github

Committed by

web-flow

Commit Message

Migrate from jest to vitest and parallelize tests (#90)

Run Details

1121 of 1250 branches covered (89.68%)

Branch coverage included in aggregate %.

388 of 393 new or added lines in 63 files covered. (98.73%)

57 existing lines in 13 files now uncovered.

6364 of 6734 relevant lines covered (94.51%)

51774.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.77

/src/crypto/implementation/default/makeNobleSignatureImpl.ts

import { DependencyError } from "../../../mlsError"
import { SignatureAlgorithm, Signature } from "../../signature"

export async function makeNobleSignatureImpl(alg: SignatureAlgorithm): Promise<Signature> {
  switch (alg) {
    case "Ed25519":
      try {
        const { ed25519 } = await import("@noble/curves/ed25519")
        return {
          async sign(signKey, message) {
            return ed25519.sign(message, signKey)
          },
          async verify(publicKey, message, signature) {
            return ed25519.verify(signature, message, publicKey)
          },
          async keygen() {
            const signKey = ed25519.utils.randomPrivateKey()
            return { signKey, publicKey: ed25519.getPublicKey(signKey) }
          },
        }
      } catch (err) {
        throw new DependencyError(
          "Optional dependency '@noble/curves' is not installed. Please install it to use this feature.",
        )
      }

    case "Ed448":
      try {
        const { ed448 } = await import("@noble/curves/ed448")
        return {
          async sign(signKey, message) {
            return ed448.sign(message, signKey)
          },
          async verify(publicKey, message, signature) {
            return ed448.verify(signature, message, publicKey)
          },
          async keygen() {
            const signKey = ed448.utils.randomPrivateKey()
            return { signKey, publicKey: ed448.getPublicKey(signKey) }
          },
        }
      } catch (err) {
        throw new DependencyError(
          "Optional dependency '@noble/curves' is not installed. Please install it to use this feature.",
        )
      }

    case "P256":
      try {
        const { p256 } = await import("@noble/curves/nist")
        return {
          async sign(signKey, message) {
            return p256.sign(message, signKey, { prehash: true }).toCompactRawBytes()
          },
          async verify(publicKey, message, signature) {
            return p256.verify(signature, message, publicKey, { prehash: true })
          },
          async keygen() {
            const signKey = p256.utils.randomPrivateKey()
            return { signKey, publicKey: p256.getPublicKey(signKey) }
          },
        }
      } catch (err) {
        throw new DependencyError(
          "Optional dependency '@noble/curves' is not installed. Please install it to use this feature.",
        )
      }
    case "P384":
      try {
        const { p384 } = await import("@noble/curves/nist")
        return {
          async sign(signKey, message) {
            return p384.sign(message, signKey, { prehash: true }).toCompactRawBytes()
          },
          async verify(publicKey, message, signature) {
            return p384.verify(signature, message, publicKey, { prehash: true })
          },
          async keygen() {
            const signKey = p384.utils.randomPrivateKey()
            return { signKey, publicKey: p384.getPublicKey(signKey) }
          },
        }
      } catch (err) {
        throw new DependencyError(
          "Optional dependency '@noble/curves' is not installed. Please install it to use this feature.",
        )
      }
    case "P521":
      try {
        const { p521 } = await import("@noble/curves/nist")
        return {
          async sign(signKey, message) {
            return p521.sign(message, signKey, { prehash: true }).toCompactRawBytes()
          },
          async verify(publicKey, message, signature) {
            return p521.verify(signature, message, publicKey, { prehash: true })
          },
          async keygen() {
            const signKey = p521.utils.randomPrivateKey()
            return { signKey, publicKey: p521.getPublicKey(signKey) }
          },
        }
      } catch (err) {
        throw new DependencyError(
          "Optional dependency '@noble/curves' is not installed. Please install it to use this feature.",
        )
      }
    case "ML-DSA-87":
      try {
        const { ml_dsa87 } = await import("@noble/post-quantum/ml-dsa")
        return {
          async sign(signKey, message) {
            return ml_dsa87.sign(signKey, message)
          },
          async verify(publicKey, message, signature) {
            return ml_dsa87.verify(publicKey, message, signature)
          },
          async keygen() {
            const keys = ml_dsa87.keygen(crypto.getRandomValues(new Uint8Array(32)))
            return { signKey: keys.secretKey, publicKey: keys.publicKey }
          },
        }
      } catch (err) {
        throw new DependencyError(
          "Optional dependency '@noble/post-quantum' is not installed. Please install it to use this feature.",
        )
      }
  }
}

1	import { DependencyError } from "../../../mlsError"	1✔
2	import { SignatureAlgorithm, Signature } from "../../signature"
3
4	export async function makeNobleSignatureImpl(alg: SignatureAlgorithm): Promise<Signature> {	1,223✔
5	switch (alg) {	1,223✔
6	case "Ed25519":	1,223✔
7	try {	538✔
8	const { ed25519 } = await import("@noble/curves/ed25519")	538✔
9	return {	538✔
10	async sign(signKey, message) {	538✔
11	return ed25519.sign(message, signKey)	5,482✔
12	},	5,482✔
13	async verify(publicKey, message, signature) {	538✔
14	return ed25519.verify(signature, message, publicKey)	15,067✔
15	},	15,067✔
16	async keygen() {	538✔
17	const signKey = ed25519.utils.randomPrivateKey()	940✔
18	return { signKey, publicKey: ed25519.getPublicKey(signKey) }	940✔
19	},	940✔
20	}	538✔
21	} catch (err) {	538!
22	throw new DependencyError(	×
UNCOV 23	"Optional dependency '@noble/curves' is not installed. Please install it to use this feature.",	×
UNCOV 24	)	×
UNCOV 25	}	×
26
27	case "Ed448":	1,223✔
28	try {	213✔
29	const { ed448 } = await import("@noble/curves/ed448")	213✔
30	return {	213✔
31	async sign(signKey, message) {	213✔
32	return ed448.sign(message, signKey)	1,246✔
33	},	1,246✔
34	async verify(publicKey, message, signature) {	213✔
35	return ed448.verify(signature, message, publicKey)	2,859✔
36	},	2,859✔
37	async keygen() {	213✔
38	const signKey = ed448.utils.randomPrivateKey()	190✔
39	return { signKey, publicKey: ed448.getPublicKey(signKey) }	190✔
40	},	190✔
41	}	213✔
42	} catch (err) {	213!
43	throw new DependencyError(	×
UNCOV 44	"Optional dependency '@noble/curves' is not installed. Please install it to use this feature.",	×
UNCOV 45	)	×
UNCOV 46	}	×
47
48	case "P256":	1,223✔
49	try {	105✔
50	const { p256 } = await import("@noble/curves/nist")	105✔
51	return {	105✔
52	async sign(signKey, message) {	105✔
53	return p256.sign(message, signKey, { prehash: true }).toCompactRawBytes()	619✔
54	},	619✔
55	async verify(publicKey, message, signature) {	105✔
56	return p256.verify(signature, message, publicKey, { prehash: true })	1,426✔
57	},	1,426✔
58	async keygen() {	105✔
59	const signKey = p256.utils.randomPrivateKey()	94✔
60	return { signKey, publicKey: p256.getPublicKey(signKey) }	94✔
61	},	94✔
62	}	105✔
63	} catch (err) {	105!
64	throw new DependencyError(	×
UNCOV 65	"Optional dependency '@noble/curves' is not installed. Please install it to use this feature.",	×
UNCOV 66	)	×
UNCOV 67	}	×
68	case "P384":	1,223✔
69	try {	102✔
70	const { p384 } = await import("@noble/curves/nist")	102✔
71	return {	102✔
72	async sign(signKey, message) {	102✔
73	return p384.sign(message, signKey, { prehash: true }).toCompactRawBytes()	611✔
74	},	611✔
75	async verify(publicKey, message, signature) {	102✔
76	return p384.verify(signature, message, publicKey, { prehash: true })	1,419✔
77	},	1,419✔
78	async keygen() {	102✔
79	const signKey = p384.utils.randomPrivateKey()	92✔
80	return { signKey, publicKey: p384.getPublicKey(signKey) }	92✔
81	},	92✔
82	}	102✔
83	} catch (err) {	102!
84	throw new DependencyError(	×
UNCOV 85	"Optional dependency '@noble/curves' is not installed. Please install it to use this feature.",	×
UNCOV 86	)	×
UNCOV 87	}	×
88	case "P521":	1,223✔
89	try {	105✔
90	const { p521 } = await import("@noble/curves/nist")	105✔
91	return {	105✔
92	async sign(signKey, message) {	105✔
93	return p521.sign(message, signKey, { prehash: true }).toCompactRawBytes()	619✔
94	},	619✔
95	async verify(publicKey, message, signature) {	105✔
96	return p521.verify(signature, message, publicKey, { prehash: true })	1,426✔
97	},	1,426✔
98	async keygen() {	105✔
99	const signKey = p521.utils.randomPrivateKey()	94✔
100	return { signKey, publicKey: p521.getPublicKey(signKey) }	94✔
101	},	94✔
102	}	105✔
103	} catch (err) {	105!
104	throw new DependencyError(	×
UNCOV 105	"Optional dependency '@noble/curves' is not installed. Please install it to use this feature.",	×
UNCOV 106	)	×
UNCOV 107	}	×
108	case "ML-DSA-87":	1,223✔
109	try {	160✔
110	const { ml_dsa87 } = await import("@noble/post-quantum/ml-dsa")	160✔
111	return {	160✔
112	async sign(signKey, message) {	160✔
113	return ml_dsa87.sign(signKey, message)	2,120✔
114	},	2,120✔
115	async verify(publicKey, message, signature) {	160✔
116	return ml_dsa87.verify(publicKey, message, signature)	3,636✔
117	},	3,636✔
118	async keygen() {	160✔
119	const keys = ml_dsa87.keygen(crypto.getRandomValues(new Uint8Array(32)))	376✔
120	return { signKey: keys.secretKey, publicKey: keys.publicKey }	376✔
121	},	376✔
122	}	160✔
123	} catch (err) {	160!
124	throw new DependencyError(	×
UNCOV 125	"Optional dependency '@noble/post-quantum' is not installed. Please install it to use this feature.",	×
UNCOV 126	)	×
UNCOV 127	}	×
128	}	1,223✔
129	}	1,223✔

LukaJCB / ts-mls / 17283659198

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous