functionalscript 0.37.0 → 0.39.0

package/fjs/crypto/pow/proof.f.js

@@ -0,0 +1,111 @@
+import { utf8 } from '../../text/module.f.js';
+import { empty, uint } from '../../types/bit_vec/module.f.js';
+import { computeSync, sha224, sha256 } from '../sha2/module.f.js';
+import { bitcoinPow, genesisNBits, genesisTarget, pow, sha256Pow, targetFromNBits } from './module.f.js';
+import { assert, assertEq, assertNotNullish } from '../../asserts/module.f.js';
+const p256 = sha256Pow;
+const p224 = pow(sha224);
+const sample = utf8('functionalscript pow proof');
+const emptyData = empty;
+/** Target large enough for {@link sample} under SHA-256 (`0x207fffff`). */
+const easyNBits = 0x207fffffn;
+/** Compact encoding for target `1` (`0x03000001`). */
+const hardNBits = 0x03000001n;
+/** SHA-256 of the empty message (NIST / Bitcoin block merkle uses this primitive). */
+const sha256EmptyHash = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n;
+/** Bitcoin block #0 header hash as big-endian uint256. */
+const block0Hash = 0x000000000019d6689c085ae165831e934ff763ae46a2a6cffb388491c27dc990n;
+const expectNull = (nBits) => {
+    assertEq(targetFromNBits(nBits), null, nBits);
+};
+export const proof = {
+    targetFromNBits: {
+        genesis: () => {
+            assertEq(targetFromNBits(genesisNBits), genesisTarget, 'genesis target');
+        },
+        block0HashWithinGenesisTarget: () => {
+            assert(!(block0Hash > genesisTarget), 'block0 hash exceeds genesis target');
+        },
+        exponent3: () => {
+            assertEq(targetFromNBits(0x030000ffn), 0xffn, 'exponent 3');
+        },
+        exponent2: () => {
+            assertEq(targetFromNBits(0x02008000n), 0x80n, 'exponent 2');
+        },
+        hardTargetOne: () => {
+            assertEq(targetFromNBits(hardNBits), 1n, 'hard target');
+        },
+        zero: () => {
+            assertEq(targetFromNBits(0n), 0n, 'zero nBits');
+        },
+        negative: () => {
+            expectNull(0x01800001n);
+        },
+        negativeHighMantissa: () => {
+            expectNull(0x22ffffffn);
+        },
+        overflowExponent: () => {
+            expectNull(0x23000001n);
+        },
+        exceeds256: () => {
+            expectNull(0x227fffffn);
+        },
+    },
+    meets: {
+        easy: () => {
+            assert(p256.meets(easyNBits)(sample), 'easy nBits should pass');
+        },
+        hard: () => {
+            assert(!(p256.meets(hardNBits)(sample)), 'target 1 should fail');
+        },
+        genesisFailsSample: () => {
+            assert(!(p256.meets(genesisNBits)(sample)), 'genesis target too hard for sample');
+        },
+        zeroTargetRejectsSample: () => {
+            assert(!(p256.meets(0n)(sample)), 'non-zero hash vs zero target');
+        },
+        invalidNBits: () => {
+            assert(!(p256.meets(0x01800001n)(sample)), 'invalid nBits should not pass');
+        },
+        hashLeqTarget: () => {
+            const h = p256.hashInt(sample);
+            const target = assertNotNullish(targetFromNBits(easyNBits), 'easy nBits decode');
+            assert(!(h > target), 'hash above easy target');
+            assert(h <= target, 'hash <= target');
+        },
+    },
+    hashInt: {
+        sha256Sample: () => {
+            const digest = computeSync(sha256)([sample]);
+            assertEq(p256.hashInt(sample), uint(digest), 'sha256 sample');
+        },
+        sha256Empty: () => {
+            assertEq(p256.hashInt(emptyData), sha256EmptyHash, 'sha256 empty constant');
+            const digest = computeSync(sha256)([emptyData]);
+            assertEq(p256.hashInt(emptyData), uint(digest), 'sha256 empty');
+        },
+        sha224: () => {
+            const digest = computeSync(sha224)([sample]);
+            assertEq(p224.hashInt(sample), uint(digest), 'sha224');
+        },
+        stable: () => {
+            assertEq(p256.hashInt(sample), p256.hashInt(sample), 'stable');
+        },
+    },
+    pow: {
+        sha256Pow: () => {
+            const built = pow(sha256);
+            assertEq(sha256Pow.hashInt(sample), built.hashInt(sample), 'hashInt');
+            assertEq(sha256Pow.meets(easyNBits)(sample), built.meets(easyNBits)(sample), 'meets');
+        },
+        bitcoinPow: () => {
+            assertEq(bitcoinPow.hashInt(sample), sha256Pow.hashInt(sample), 'bitcoinPow');
+        },
+        independentInstances: () => {
+            const a = pow(sha256);
+            const b = pow(sha256);
+            assertEq(a.hashInt(sample), b.hashInt(sample), 'hashInt');
+            assertEq(a.meets(easyNBits)(sample), b.meets(easyNBits)(sample), 'meets');
+        },
+    },
+};

package/{fs → fjs}/crypto/secp/proof.f.js

@@ -1,4 +1,4 @@
-import { assert } from '../../asserts/module.f.js';
+import { assert, assertEq, assertNotNullish } from '../../asserts/module.f.js';
 import { prime_field } from '../../types/prime_field/module.f.js';
 import { curve, secp256k1, secp192r1, secp256r1, eq, secp384r1, secp521r1 } from './module.f.js';
 const poker = (param) => () => {
@@ -44,13 +44,9 @@ const poker = (param) => () => {
     //
     let m = 0n;
     for (const p of dN) {
-        if (p === null) {
-            throw 'null';
-        }
+        assert(p !== null, 'null');
         const x = p[0] & 0x3fn;
-        if (x !== m) {
-            throw [p[0], x, m];
-        }
+        assertEq(x, m, [p[0], x, m]);
         ++m;
     }
 };
@@ -72,42 +68,25 @@ export const proof = {
         const test_curve = c => {
             const { mul, neg, pf: { abs }, y: yf, nf: { p: n }, g } = c;
             const point_check = (p) => {
-                if (p === null) {
-                    throw 'p === null';
-                }
+                assert(p !== null, 'p === null');
                 const [x, y] = p;
-                const ye = yf(x);
-                if (ye === null) {
-                    throw 'ye === null';
-                }
-                if (abs(ye) !== abs(y)) {
-                    throw 'ye';
-                }
+                const ye = assertNotNullish(yf(x), 'ye === null');
+                assertEq(abs(ye), abs(y), 'ye');
             };
             point_check(g);
             point_check(neg(g));
             const test_mul = (p) => {
-                if (mul(0n)(p) !== null) {
-                    throw 'O';
-                }
-                if (mul(1n)(p) !== p) {
-                    throw 'p';
-                }
-                if (mul(n)(p) !== null) {
-                    throw 'n';
-                }
+                assertEq(mul(0n)(p), null, 'O');
+                assertEq(mul(1n)(p), p, 'p');
+                assertEq(mul(n)(p), null, 'n');
                 const pn = neg(p);
-                if (!eq(mul(n - 1n)(p))(pn)) {
-                    throw 'n - 1';
-                }
+                assert(eq(mul(n - 1n)(p))(pn), 'n - 1');
                 const f = s => {
                     const r = mul(s)(p);
                     point_check(r);
                     const rn = mul(s)(pn);
                     point_check(rn);
-                    if (!eq(r)(neg(rn))) {
-                        throw 'r != -rn';
-                    }
+                    assert(eq(r)(neg(rn)), 'r != -rn');
                 };
                 f(2n);
                 f(3n);
@@ -136,7 +115,7 @@ export const proof = {
     // Cover null (point at infinity) branches in neg, add, and eq.
     nullPointOps: () => {
         const c = secp256k1;
-        assert(c.neg(null) === null);
+        assertEq(c.neg(null), null);
         assert(eq(null)(null));
         assert(!eq(null)(c.g));
         assert(!eq(c.g)(null));

package/{fs → fjs}/crypto/sha2/proof.f.js

@@ -1,13 +1,12 @@
 import { utf8 } from '../../text/module.f.js';
 import { repeat, uint, vec } from '../../types/bit_vec/module.f.js';
 import { flip } from '../../types/function/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 import { map } from '../../types/list/module.f.js';
 import { base32, base64, computeSync, sha224, sha256, sha384, sha512, sha512x224, sha512x256, } from './module.f.js';
 const checkEmpty = ({ init, end, hashLength }) => (x) => {
     const result = end(init);
-    if (result !== vec(hashLength)(x)) {
-        throw [result, x];
-    }
+    assertEq(result, vec(hashLength)(x), [result, x]);
 };
 // https://en.wikipedia.org/wiki/SHA-2#Test_vectors
 //
@@ -21,16 +20,12 @@ export const proof = {
                 s256: () => {
                     const result = fromV8(compress(sha256.init.hash)(e));
                     const x = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n;
-                    if (result !== x) {
-                        throw [result.toString(16), x.toString(16)];
-                    }
+                    assertEq(result, x, [result.toString(16), x.toString(16)]);
                 },
                 s224: () => {
                     const result = fromV8(compress(sha224.init.hash)(e)) >> 32n;
                     const x = 0xd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42fn;
-                    if (result !== x) {
-                        throw [result, x];
-                    }
+                    assertEq(result, x, [result, x]);
                 },
             };
         },
@@ -41,30 +36,22 @@ export const proof = {
                 s512: () => {
                     const result = fromV8(compress(sha512.init.hash)(e));
                     const x = 0xcf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3en;
-                    if (result !== x) {
-                        throw [result, x];
-                    }
+                    assertEq(result, x, [result, x]);
                 },
                 s384: () => {
                     const result = fromV8(compress(sha384.init.hash)(e)) >> 128n;
                     const x = 0x38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95bn;
-                    if (result !== x) {
-                        throw [result, x];
-                    }
+                    assertEq(result, x, [result, x]);
                 },
                 s512x256: () => {
                     const result = fromV8(base64.compress(sha512x256.init.hash)(e)) >> 256n;
                     const x = 0xc672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967an;
-                    if (result !== x) {
-                        throw [result, x];
-                    }
+                    assertEq(result, x, [result, x]);
                 },
                 s512x224: () => {
                     const result = fromV8(compress(sha512x224.init.hash)(e)) >> 288n;
                     const x = 0x6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4n;
-                    if (result !== x) {
-                        throw [result, x];
-                    }
+                    assertEq(result, x, [result, x]);
                 },
             };
         }
@@ -83,36 +70,26 @@ export const proof = {
             {
                 const s = utf8("The quick brown fox jumps over the lazy dog");
                 const h = computeSync(sha224)([s]);
-                if (uint(h) !== e) {
-                    throw h;
-                }
+                assertEq(uint(h), e, h);
             }
             {
                 const s = ['The', ' quick', ' brown', ' fox', ' jumps', ' over', ' the', ' lazy', ' dog'];
                 const h = computeSync(sha224)(map(utf8)(s));
-                if (uint(h) !== e) {
-                    throw h;
-                }
+                assertEq(uint(h), e, h);
             }
         },
         () => {
             const s = utf8("The quick brown fox jumps over the lazy dog.");
             const h = computeSync(sha224)([s]);
-            if (uint(h) !== 0x619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn) {
-                throw h;
-            }
+            assertEq(uint(h), 0x619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn, h);
         },
         () => {
             const s = utf8("hello world");
-            if (uint(s) !== 0x68656c6c6f20776f726c64n) {
-                throw s;
-            }
+            assertEq(uint(s), 0x68656c6c6f20776f726c64n, s);
             let state = sha256.init;
             state = sha256.append(s)(state);
             const h = sha256.end(state);
-            if (uint(h) !== 0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9n) {
-                throw h;
-            }
+            assertEq(uint(h), 0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9n, h);
         }
     ],
     fill: () => {
@@ -123,18 +100,14 @@ export const proof = {
                 let state = sha256.init;
                 state = sha256.append(r)(state);
                 const h = uint(sha256.end(state));
-                if (h >> 224n !== 0x8a83665fn) {
-                    throw h;
-                }
+                assertEq(h >> 224n, 0x8a83665fn, h);
             },
             16: () => {
                 const r = times(16n);
                 let state = sha256.init;
                 state = sha256.append(r)(state);
                 const h = sha256.end(state);
-                if (uint(h) !== 0x3138bb9bc78df27c473ecfd1410f7bd45ebac1f59cf3ff9cfe4db77aab7aedd3n) {
-                    throw h;
-                }
+                assertEq(uint(h), 0x3138bb9bc78df27c473ecfd1410f7bd45ebac1f59cf3ff9cfe4db77aab7aedd3n, h);
             }
         };
     },
@@ -144,9 +117,7 @@ export const proof = {
             const msg = flip(repeat)(zero)(113n);
             const h = computeSync(sha384)([msg]);
             const x = 0x6be9af2cf3cd5dd12c8d9399ec2b34e66034fbd699d4e0221d39074172a380656089caafe8f39963f94cc7c0a07e3d21n;
-            if (uint(h) !== x) {
-                throw h;
-            }
+            assertEq(uint(h), x, h);
         },
     },
     // Regression guard (sha2-append-quadratic): `append` used to be
@@ -155,7 +126,7 @@ export const proof = {
     // O(n²); now near-linear (~40-60ms on Node, well under `bun test`'s 5s
     // per-test limit on Bun). No timing assertion (duration varies by
     // engine/machine); relies on the test runner's own per-test timing to
-    // catch a regression, same convention as `fs/basen/base64/proof.f.ts`
+    // catch a regression, same convention as `fjs/basen/base64/proof.f.ts`
     // `encodeLargeVecIsSlow`.
     appendLargeVecIsFast: () => {
         const big = repeat(100000n)(vec(8n)(0xffn));
@@ -163,8 +134,6 @@ export const proof = {
         state = sha256.append(big)(state);
         const h = sha256.end(state);
         const x = 0xbe87f6dbe42cdf682276fbecab3636fbfcaa008cf454d635dd77872b50d940aan;
-        if (uint(h) !== x) {
-            throw h;
-        }
+        assertEq(uint(h), x, h);
     },
 };

package/{fs → fjs}/crypto/sign/module.f.d.ts

@@ -1,8 +1,3 @@
-/**
- * Signing helpers built on secp256k1 and SHA-256 primitives.
- *
- * @module
- */
 import type { Array2 } from '../../types/array/module.f.ts';
 import { type Vec } from '../../types/bit_vec/module.f.ts';
 import type { Curve } from '../secp/module.f.ts';

package/{fs → fjs}/crypto/sign/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * Signing helpers built on secp256k1 and SHA-256 primitives.
+ *
+ * @module
+ */
+import { assertNotNullish } from '../../asserts/module.f.js';
 import { bitLength, divUp8, roundUp8 } from '../../types/bigint/module.f.js';
 import { empty, length, msb, repeat, unpack, vec, vec8 } from '../../types/bit_vec/module.f.js';
 import { hmac } from '../hmac/module.f.js';
@@ -139,13 +145,10 @@ export const sign = (c) => (hf) => (x) => (m) => {
     //
     //     If r turns out to be zero, a new k should be selected and r
     //     computed again (this is an utterly improbable occurrence).
-    const rxy = c.mul(k)(g);
     // TODO: implement the loop. `computeK` should either
     // - accept a state (current `k`).
     // - accept a `is_valid` function.
-    if (rxy === null) {
-        throw 'rxy === null';
-    }
+    const rxy = assertNotNullish(c.mul(k)(g), 'rxy === null');
     const [r] = rxy;
     // 4.  The value s (modulo q) is computed:
     //

package/{fs → fjs}/crypto/sign/proof.f.js

@@ -4,6 +4,7 @@ import { hmac } from "../hmac/module.f.js";
 import { secp192r1, secp256r1, secp384r1, secp521r1 } from "../secp/module.f.js";
 import { computeSync, sha224, sha256, sha384, sha512 } from "../sha2/module.f.js";
 import { all, concat, computeK, fromCurve, sign } from "./module.f.js";
+import { assertEq } from '../../asserts/module.f.js';
 const sample = utf8("sample");
 const test = utf8("test");
 const x00 = vec8(0x00n);
@@ -15,172 +16,108 @@ const r32 = repeat(32n);
 const hmac256 = hmac(sha256);
 export const proof = {
     bits2int: () => {
-        if (all(7n).bits2int(vec(5n)(20n)) !== 5n) {
-            throw new Error("fail");
-        }
-        if (all(17n).bits2int(vec(3n)(5n)) !== 5n) {
-            throw new Error("fail");
-        }
+        assertEq(all(7n).bits2int(vec(5n)(20n)), 5n, new Error("fail"));
+        assertEq(all(17n).bits2int(vec(3n)(5n)), 5n, new Error("fail"));
     },
     int2octets: () => {
         // 3 bit prime
-        if (all(5n).int2octets(5n) !== vec(8n)(5n)) {
-            throw new Error("fail");
-        }
+        assertEq(all(5n).int2octets(5n), vec(8n)(5n), new Error("fail"));
         // 5 bit prime
-        if (all(17n).int2octets(20n) !== vec(8n)(20n)) {
-            throw new Error("fail");
-        }
+        assertEq(all(17n).int2octets(20n), vec(8n)(20n), new Error("fail"));
         // 15 bit prime
-        if (all(16387n).int2octets(0x13n) !== vec(16n)(0x13n)) {
-            throw new Error("fail");
-        }
+        assertEq(all(16387n).int2octets(0x13n), vec(16n)(0x13n), new Error("fail"));
     },
     bit2octets: () => {
-        if (all(11n).bits2octets(vec(4n)(13n)) !== vec(8n)(2n)) {
-            throw new Error("fail");
-        }
+        assertEq(all(11n).bits2octets(vec(4n)(13n)), vec(8n)(2n), new Error("fail"));
     },
     k: () => {
         //
         const q = 0x4000000000000000000020108a2e0cc0d99f8a5efn;
         const { qlen, int2octets, bits2octets, bits2int } = all(q);
-        if (qlen !== 163n) {
-            throw qlen;
-        }
+        assertEq(qlen, 163n);
         const x = 0x09a4d6792295a7f730fc3f2b49cbc0f62e862272fn;
         const h1 = computeSync(sha256)([sample]);
-        if (h1 !== v256(0xaf2bdbe1aa9b6ec1e2ade1d694f41fc71a831d0268e9891562113d8a62add1bfn)) {
-            throw h1;
-        }
+        assertEq(h1, v256(0xaf2bdbe1aa9b6ec1e2ade1d694f41fc71a831d0268e9891562113d8a62add1bfn));
         const xi2o = int2octets(x);
-        if (xi2o !== v168(0x009a4d6792295a7f730fc3f2b49cbc0f62e862272fn)) {
-            throw xi2o;
-        }
+        assertEq(xi2o, v168(0x009a4d6792295a7f730fc3f2b49cbc0f62e862272fn));
         const h1b2o = bits2octets(h1);
-        if (h1b2o !== v168(0x01795edf0d54db760f156d0dac04c0322b3a204224n)) {
-            throw h1b2o;
-        }
+        assertEq(h1b2o, v168(0x01795edf0d54db760f156d0dac04c0322b3a204224n));
         let v = r32(x01);
-        if (v !== v256(0x0101010101010101010101010101010101010101010101010101010101010101n)) {
-            throw v;
-        }
+        assertEq(v, v256(0x0101010101010101010101010101010101010101010101010101010101010101n));
         let k = r32(x00);
-        if (k !== v256(0x0000000000000000000000000000000000000000000000000000000000000000n)) {
-            throw k;
-        }
+        assertEq(k, v256(0x0000000000000000000000000000000000000000000000000000000000000000n));
         // d.
         // 256 + 8 + 168 + 168 = 600
         const vv = concat(v, x00, xi2o, h1b2o);
         const vvu = 0x010101010101010101010101010101010101010101010101010101010101010100009a4d6792295a7f730fc3f2b49cbc0f62e862272f01795edf0d54db760f156d0dac04c0322b3a204224n;
-        if (vv !== v600(vvu)) {
-            throw [vv.toString(16), vvu.toString(16)];
-        }
+        assertEq(vv, v600(vvu), [vv.toString(16), vvu.toString(16)]);
         k = hmac256(k)(vv);
-        if (k !== v256(0x09999a9bfef972d3346911883fad7951d23f2c8b47f420222d1171eeeeac5ab8n)) {
-            throw k;
-        }
+        assertEq(k, v256(0x09999a9bfef972d3346911883fad7951d23f2c8b47f420222d1171eeeeac5ab8n));
         // e.
         v = hmac256(k)(v);
-        if (v !== v256(0xd5f4030f755ee86aa10bba8c09df114ff6b6111c238500d13c7343a8c01becf7n)) {
-            throw v;
-        }
+        assertEq(v, v256(0xd5f4030f755ee86aa10bba8c09df114ff6b6111c238500d13c7343a8c01becf7n));
         // f. K = HMAC_K(V || 0x01 || int2octets(x) || bits2octets(h1))
         k = hmac256(k)(concat(v, x01, xi2o, h1b2o));
-        if (k !== v256(0x0cf2fe96d5619c9ef53cb7417d49d37ea68a4ffed0d7e623e38689289911bd57n)) {
-            throw k;
-        }
+        assertEq(k, v256(0x0cf2fe96d5619c9ef53cb7417d49d37ea68a4ffed0d7e623e38689289911bd57n));
         // g.
         v = hmac256(k)(v);
-        if (v !== v256(0x783457c1cf3148a8f2a9ae73ed472fa98ed9cd925d8e964ce0764def3f842b9an)) {
-            throw v;
-        }
+        assertEq(v, v256(0x783457c1cf3148a8f2a9ae73ed472fa98ed9cd925d8e964ce0764def3f842b9an));
         // h.
         v = hmac256(k)(v);
         let t = msb.concat(empty)(v);
-        if (t !== v256(0x9305a46de7ff8eb107194debd3fd48aa20d5e7656cbe0ea69d2a8d4e7c67314an)) {
-            throw t;
-        }
+        assertEq(t, v256(0x9305a46de7ff8eb107194debd3fd48aa20d5e7656cbe0ea69d2a8d4e7c67314an));
         // 3.
         let kk = bits2int(t);
-        if (kk !== 0x4982d236f3ffc758838ca6f5e9fea455106af3b2bn) {
-            throw kk;
-        }
+        assertEq(kk, 0x4982d236f3ffc758838ca6f5e9fea455106af3b2bn);
         // 3. second try
         k = hmac256(k)(concat(v, x00));
-        if (k !== v256(0x75cb5c05b2a78c3d81df12d74d7be0a0e94ab19815781d4d8e2902a79d0a6699n)) {
-            throw k;
-        }
+        assertEq(k, v256(0x75cb5c05b2a78c3d81df12d74d7be0a0e94ab19815781d4d8e2902a79d0a6699n));
         v = hmac256(k)(v);
-        if (v !== v256(0xdcb9ca126107a9c27ce77ba58ea871c8c912d835eaddc305f2445d88f66c4c43n)) {
-            throw v;
-        }
+        assertEq(v, v256(0xdcb9ca126107a9c27ce77ba58ea871c8c912d835eaddc305f2445d88f66c4c43n));
         v = hmac256(k)(v);
         t = msb.concat(empty)(v);
-        if (t !== v256(0xc70c78608a3b5be9289be90ef6e81a9e2c1516d5751d2f75f50033e45f73bdebn)) {
-            throw t;
-        }
+        assertEq(t, v256(0xc70c78608a3b5be9289be90ef6e81a9e2c1516d5751d2f75f50033e45f73bdebn));
         kk = bits2int(t);
-        if (kk !== 0x63863c30451dadf4944df4877b740d4f160a8b6abn) {
-            throw kk;
-        }
+        assertEq(kk, 0x63863c30451dadf4944df4877b740d4f160a8b6abn);
         // 3. third try
         k = hmac256(k)(concat(v, x00));
-        if (k !== v256(0x0a5a64b99c059520103686cb6f36bcfca788eb3bcf69ba66a5bb080b0593ba53n)) {
-            throw k;
-        }
+        assertEq(k, v256(0x0a5a64b99c059520103686cb6f36bcfca788eb3bcf69ba66a5bb080b0593ba53n));
         v = hmac256(k)(v);
-        if (v !== v256(0x0b3b196811b19f6c6f729c43f35bcf0dfd725f17ca3430e8721453e55550a18fn)) {
-            throw v;
-        }
+        assertEq(v, v256(0x0b3b196811b19f6c6f729c43f35bcf0dfd725f17ca3430e8721453e55550a18fn));
         v = hmac256(k)(v);
         t = msb.concat(empty)(v);
-        if (t !== v256(0x475e80e992140567fcc3a50dab90fe84bcd7bb03638e9c4656a06f37f6508a7cn)) {
-            throw t;
-        }
+        assertEq(t, v256(0x475e80e992140567fcc3a50dab90fe84bcd7bb03638e9c4656a06f37f6508a7cn));
         kk = bits2int(t);
-        if (kk !== 0x23af4074c90a02b3fe61d286d5c87f425e6bdd81bn) {
-            throw kk;
-        }
+        assertEq(kk, 0x23af4074c90a02b3fe61d286d5c87f425e6bdd81bn);
     },
     computeK: () => {
         const q = 0x4000000000000000000020108a2e0cc0d99f8a5efn;
         const a = all(q);
-        if (a.qlen !== 163n) {
-            throw a.qlen;
-        }
+        assertEq(a.qlen, 163n);
         const x = 0x09a4d6792295a7f730fc3f2b49cbc0f62e862272fn;
         const k = computeK(a)(sha256)(x)(sample);
-        if (k !== 0x23af4074c90a02b3fe61d286d5c87f425e6bdd81bn) {
-            throw k;
-        }
+        assertEq(k, 0x23af4074c90a02b3fe61d286d5c87f425e6bdd81bn);
     },
     investigate: () => {
         const q = 0xf2c3119374ce76c9356990b465374a17f23f9ed35089bd969f61c6dde9998c1fn;
         const x = 0x69c7548c21d0dfea6b9a51c9ead4e27c33d3b3f180316e5bcab92c933f0e4dbcn;
         const a = all(q);
         const k = computeK(a)(sha384)(x)(sample);
-        if (k !== 0xc345d5ab3da0a5bcb7ec8f8fb7a7e96069e03b206371ef7d83e39068ec564920n) {
-            throw k;
-        }
+        assertEq(k, 0xc345d5ab3da0a5bcb7ec8f8fb7a7e96069e03b206371ef7d83e39068ec564920n);
     },
     kk: () => {
         const a = fromCurve(secp192r1);
         const x = 0x6fab034934e4c0fc9ae67f5b5659a9d7d1fefd187ee09fd4n;
         const m = utf8("sample");
         const kk = computeK(a)(sha224)(x)(m);
-        if (kk !== 0x4381526b3fc1e7128f202e194505592f01d5ff4c5af015d8n) {
-            throw kk;
-        }
+        assertEq(kk, 0x4381526b3fc1e7128f202e194505592f01d5ff4c5af015d8n);
     },
     a2: () => {
         const check = ({ q, x, msg0, msg1 }) => {
             const a = all(q);
             const check = (sha, expected, m) => {
                 const k = computeK(a)(sha)(x)(m);
-                if (k !== expected) {
-                    throw [k.toString(16), expected.toString(16)];
-                }
+                assertEq(k, expected, [k.toString(16), expected.toString(16)]);
             };
             const check4 = (m, h) => {
                 check(sha224, h[0], m);
@@ -410,16 +347,10 @@ export const proof = {
             const a = all(q.nf.p);
             const check = (sha, { k, r, s }, m) => {
                 const k0 = computeK(a)(sha)(x)(m);
-                if (k0 !== k) {
-                    throw [k0.toString(16), k.toString(16)];
-                }
+                assertEq(k0, k, [k0.toString(16), k.toString(16)]);
                 const [r0, s0] = sign(q)(sha)(x)(m);
-                if (r0 !== r) {
-                    throw [r0, r];
-                }
-                if (s0 !== s) {
-                    throw [s0, s];
-                }
+                assertEq(r0, r, [r0, r]);
+                assertEq(s0, s, [s0, s]);
             };
             const check4 = (m, h) => {
                 check(sha224, h[0], m);