diff --git a/src/__tests__/address.test.ts b/src/__tests__/address.test.ts
new file mode 100644
index 0000000..1beace7
--- /dev/null
+++ b/src/__tests__/address.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { deriveAddress, isValidAddress } from "../address.js";
+import { CurveType } from "../types.js";
+
+describe("deriveAddress", () => {
+  it("derives addresses for valid public key sizes", () => {
+    const publicKeys = [
+      ["11".repeat(32), CurveType.ED25519],
+      ["22".repeat(48), CurveType.BLS12381],
+      ["02" + "33".repeat(32), CurveType.SECP256K1],
+      ["44".repeat(64), CurveType.ETHSECP256K1],
+      ["04" + "55".repeat(64), CurveType.ETHSECP256K1],
+    ] as const;
+
+    for (const [publicKey, curveType] of publicKeys) {
+      expect(isValidAddress(deriveAddress(publicKey, curveType))).toBe(true);
+    }
+  });
+
+  it("rejects public keys with invalid sizes", () => {
+    const invalidPublicKeys = [
+      ["11".repeat(31), CurveType.ED25519],
+      ["22".repeat(47), CurveType.BLS12381],
+      ["33".repeat(32), CurveType.SECP256K1],
+      ["44".repeat(63), CurveType.ETHSECP256K1],
+    ] as const;
+
+    for (const [publicKey, curveType] of invalidPublicKeys) {
+      expect(() => deriveAddress(publicKey, curveType)).toThrow("public key size");
+    }
+  });
+});
\ No newline at end of file
diff --git a/src/address.ts b/src/address.ts
index 5549ea9..170e84d 100644
--- a/src/address.ts
+++ b/src/address.ts
@@ -4,11 +4,39 @@ import { keccak_256 } from "@noble/hashes/sha3.js";
 import { hexToBytes, bytesToHex } from "@noble/hashes/utils.js";
 import { CurveType, KEY_SIZES } from "./types.js";
 
+function assertPublicKeySize(curveType: CurveType, length: number): void {
+  switch (curveType) {
+    case CurveType.ED25519:
+      if (length !== KEY_SIZES.PUBLIC.ED25519) {
+        throw new Error(`Invalid ED25519 public key size: ${length}`);
+      }
+      return;
+    case CurveType.BLS12381:
+      if (length !== KEY_SIZES.PUBLIC.BLS12381) {
+        throw new Error(`Invalid BLS12381 public key size: ${length}`);
+      }
+      return;
+    case CurveType.SECP256K1:
+      if (length !== KEY_SIZES.PUBLIC.SECP256K1) {
+        throw new Error(`Invalid SECP256K1 public key size: ${length}`);
+      }
+      return;
+    case CurveType.ETHSECP256K1:
+      if (length !== KEY_SIZES.PUBLIC.ETHSECP256K1 && length !== 65) {
+        throw new Error(`Invalid ETHSECP256K1 public key size: ${length}`);
+      }
+      return;
+    default:
+      return;
+  }
+}
+
 export function deriveAddress(
   publicKeyHex: string,
   curveType: CurveType
 ): string {
   const pubKeyBytes = hexToBytes(publicKeyHex);
+  assertPublicKeySize(curveType, pubKeyBytes.length);
 
   switch (curveType) {
     case CurveType.ED25519: {
diff --git a/src/keystore.ts b/src/keystore.ts
index 193bde3..120ffc1 100644
--- a/src/keystore.ts
+++ b/src/keystore.ts
@@ -26,9 +26,12 @@ export function importFromGoKeystore(
   const curveType = detectPublicKeyCurve(entry.publicKey);
 
   const derivedAddress = deriveAddress(entry.publicKey, curveType);
+  // Throw instead of warn: a mismatch means the entry is tampered or corrupted.
+  // Silently importing the wrong address would cause funds to be sent to the
+  // wrong destination or transactions to be rejected by the network.
   if (derivedAddress.toLowerCase() !== entry.keyAddress.toLowerCase()) {
-    console.warn(
-      `Address mismatch: expected ${entry.keyAddress}, derived ${derivedAddress}`
+    throw new Error(
+      `Keystore integrity check failed: stored address ${entry.keyAddress} does not match address derived from public key ${derivedAddress}. The keystore entry may be corrupted or tampered.`
     );
   }
 
diff --git a/src/provably-fair.ts b/src/provably-fair.ts
index a60371d..f849c84 100644
--- a/src/provably-fair.ts
+++ b/src/provably-fair.ts
@@ -36,7 +36,15 @@ export function computeHMAC(
 
 /**
  * Computes a dice roll in the range [0, 9999] from the given seeds and nonce.
- * Maps the first 4 bytes of HMAC-SHA256 to a uint32, then takes modulo 10000.
+ *
+ * Uses rejection sampling over successive 4-byte HMAC windows to eliminate
+ * modulo bias. A naive `uint32 % 10000` is biased because 2^32 (4 294 967 296)
+ * is not evenly divisible by 10000 — values 0–7295 appear once more often than
+ * values 7296–9999, giving the house a hidden systematic edge on those outcomes.
+ *
+ * Rejection threshold: 4 294 960 000 (= floor(2^32 / 10000) * 10000).
+ * Values at or above the threshold are discarded and the next 4-byte window is
+ * tried. In practice fewer than 2 iterations are needed on average.
  */
 export function computeDiceRoll(
   serverSeed: string,
@@ -44,9 +52,16 @@ export function computeDiceRoll(
   nonce: number
 ): number {
   const h = computeHMAC(serverSeed, clientSeed, nonce);
-  const view = new DataView(h.buffer, h.byteOffset, h.byteLength);
-  const raw = view.getUint32(0, false); // big-endian
-  return raw % 10000;
+  const RANGE = 10000;
+  const THRESHOLD = Math.floor(0x100000000 / RANGE) * RANGE; // 4_294_960_000
+  for (let offset = 0; offset + 4 <= h.length; offset += 4) {
+    const view = new DataView(h.buffer, h.byteOffset + offset, 4);
+    const raw = view.getUint32(0, false); // big-endian
+    if (raw < THRESHOLD) return raw % RANGE;
+  }
+  // Fallback (astronomically unlikely): use modulo on last window
+  const view = new DataView(h.buffer, h.byteOffset, 4);
+  return view.getUint32(0, false) % RANGE;
 }
 
 /**
@@ -63,18 +78,30 @@ export function verifyDiceRoll(
 
 /**
  * Computes the crash point for a rocket round.
- * Uses HMAC-SHA256(serverSeed, nonce) with 3% house edge.
+ * Uses HMAC-SHA256(serverSeed, clientSeed:nonce) with 3% house edge.
  * Result is clamped to [1.01, 100.0].
+ *
+ * @param clientSeed - Player-supplied seed that contributes entropy to the outcome.
+ *   Must not be empty: passing "" removes the client's ability to independently
+ *   influence and verify the result, breaking the provably-fair guarantee.
  */
 export function computeCrashPoint(
   serverSeed: string,
+  clientSeed: string,
   nonce: number
 ): number {
-  const h = computeHMAC(serverSeed, "", nonce);
+  if (!clientSeed) {
+    throw new Error("clientSeed must not be empty — an empty client seed removes player entropy from the provably-fair computation");
+  }
+  const h = computeHMAC(serverSeed, clientSeed, nonce);
   const hex8 = bytesToHex(h).slice(0, 8);
   const result = parseInt(hex8, 16) >>> 0; // unsigned 32-bit
 
-  if (result % 33 === 0) return 1.0;
+  // Instant-crash case: return the advertised floor (1.01), not 1.0.
+  // The docstring and UI both promise outcomes in [1.01, 100.0]; returning
+  // 1.0 violates the stated minimum and gives players a worse payout than
+  // the published house-edge formula implies.
+  if (result % 33 === 0) return 1.01;
 
   const houseEdge = 0.03;
   const e = 0x100000000;
@@ -83,4 +110,4 @@ export function computeCrashPoint(
   if (crashPoint < 1.01) crashPoint = 1.01;
   if (crashPoint > 100.0) crashPoint = 100.0;
   return crashPoint;
-}
+}
\ No newline at end of file