Fix test nitpicks: pin expected digests, reuse helpers, fix f64 precision (#7)

- eip712: Replace determinism-only checks with pinned canonical EIP-712
  digest vectors for Permit and Permit2 PermitSingle tests
- hd_wallet: Pin exact expected master key and chain_code bytes for
  BIP-32 test instead of non-zero checks
- secp256k1: Replace manual half-order comparison with existing isHighS
  helper and HALF_ORDER_BYTES constant
- units: Use 9007.0 ETH (within f64 exact integer range) instead of
  10000.0 to avoid misleading f64 precision behavior

Author: koko1123

src/eip712.zig

@@ -1058,11 +1058,10 @@ test "ERC20 Permit typed data hash" {
     };
 
     const hash1 = try hashTypedData(allocator, domain, permit_msg, &type_defs);
-    const hash2 = try hashTypedData(allocator, domain, permit_msg, &type_defs);
 
-    // Verify deterministic 32-byte result
-    try testing.expectEqual(@as(usize, 32), hash1.len);
-    try testing.expectEqualSlices(u8, &hash1, &hash2);
+    // Verify against canonical expected EIP-712 digest
+    const expected_permit_hash = try hex.hexToBytesFixed(32, "a291091bcb960bb950bcde8c114f51268db75fc46b0bd1ed9d0b98e99b7c0b78");
+    try testing.expectEqualSlices(u8, &expected_permit_hash, &hash1);
 }
 
 test "hashDomain with all 5 fields" {
@@ -1198,9 +1197,8 @@ test "Permit2 PermitSingle nested struct" {
     };
 
     const hash1 = try hashTypedData(allocator, domain, permit_single, &type_defs);
-    const hash2 = try hashTypedData(allocator, domain, permit_single, &type_defs);
 
-    // Verify deterministic 32-byte result
-    try testing.expectEqual(@as(usize, 32), hash1.len);
-    try testing.expectEqualSlices(u8, &hash1, &hash2);
+    // Verify against canonical expected EIP-712 digest
+    const expected_permit2_hash = try hex.hexToBytesFixed(32, "deb9a47018f32b20c6e10646036eae3ad57736889291e780cd092389f05f19ad");
+    try testing.expectEqualSlices(u8, &expected_permit2_hash, &hash1);
 }

src/hd_wallet.zig

@@ -235,26 +235,12 @@ test "BIP-32 master key from known seed" {
     @memcpy(seed[0..32], &first_half);
 
     const master = try masterKeyFromSeed(seed);
-    // Master key should be non-zero
-    var key_nonzero = false;
-    for (master.key) |b| if (b != 0) {
-        key_nonzero = true;
-        break;
-    };
-    try std.testing.expect(key_nonzero);
-
-    // Chain code should be non-zero
-    var cc_nonzero = false;
-    for (master.chain_code) |b| if (b != 0) {
-        cc_nonzero = true;
-        break;
-    };
-    try std.testing.expect(cc_nonzero);
 
-    // Deterministic
-    const master2 = try masterKeyFromSeed(seed);
-    try std.testing.expectEqualSlices(u8, &master.key, &master2.key);
-    try std.testing.expectEqualSlices(u8, &master.chain_code, &master2.chain_code);
+    // Pin exact expected BIP-32 vector outputs
+    const expected_key = try hex_mod.hexToBytesFixed(32, "4cc2c096af45067fed8c711d57ed5c4923eb3ee761e08f5474c33754b80c9d0f");
+    const expected_chain_code = try hex_mod.hexToBytesFixed(32, "2218ccd37b9b7c6d41122fed49d2ddcc151b2f463301b8fa9d5067bdbdb40af2");
+    try std.testing.expectEqualSlices(u8, &expected_key, &master.key);
+    try std.testing.expectEqualSlices(u8, &expected_chain_code, &master.chain_code);
 }
 
 test "known mnemonic abandon...about to exact address" {

src/secp256k1.zig

@@ -501,36 +501,14 @@ test "sign produces low-s (EIP-2) canonical signature" {
     // Hardhat account #0
     const private_key = try hex.hexToBytesFixed(32, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
 
-    // n/2 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0
-    const half_n: [32]u8 = .{
-        0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-        0x5D, 0x57, 0x6E, 0x73, 0x57, 0xA4, 0x50, 0x1D,
-        0xDF, 0xE9, 0x2F, 0x46, 0x68, 0x1B, 0x20, 0xA0,
-    };
-
     const messages = [_][]const u8{ "canonical1", "canonical2", "canonical3", "canonical4", "canonical5" };
 
     for (messages) |msg| {
         const message_hash = keccak.hash(msg);
         const sig = try sign(private_key, message_hash);
 
-        // Extract s as big-endian bytes and verify s <= n/2
-        const s_bytes = sig.s;
-        var s_is_lte = false;
-        for (0..32) |i| {
-            if (s_bytes[i] < half_n[i]) {
-                s_is_lte = true;
-                break;
-            } else if (s_bytes[i] > half_n[i]) {
-                break;
-            }
-        }
-        // If we didn't break early, all bytes were equal (s == n/2), which is also valid
-        if (!s_is_lte) {
-            // Check if all bytes are equal (s == n/2)
-            s_is_lte = std.mem.eql(u8, &s_bytes, &half_n);
-        }
-        try std.testing.expect(s_is_lte);
+        // Verify s <= n/2 using the existing isHighS helper and HALF_ORDER_BYTES
+        const s_scalar = Scalar.fromBytes(sig.s, .big) catch unreachable;
+        try std.testing.expect(!isHighS(s_scalar));
     }
 }

src/utils/units.zig

@@ -55,7 +55,8 @@ test "parseEther zero" {
 }
 
 test "parseEther large value" {
-    try std.testing.expectEqual(@as(u256, 10_000_000_000_000_000_000_000), parseEther(10000.0));
+    // Use 9007.0 which is within f64's exact integer range (2^53)
+    try std.testing.expectEqual(@as(u256, 9007_000_000_000_000_000_000), parseEther(9007.0));
 }
 
 test "formatEther zero" {