From 229593cab096485901dd4b7504d0573ddbe75b84 Mon Sep 17 00:00:00 2001 From: AMATH <116212274+amathxbt@users.noreply.github.com> Date: Sat, 4 Jul 2026 08:12:51 +0100 Subject: [PATCH 1/5] fix(keystore): throw on address mismatch instead of silently warning (#2) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit importFromGoKeystore() compared the stored keyAddress against the address derived from the public key, but only issued a console.warn on mismatch and then silently returned the stored (wrong) address. A corrupted or tampered keystore entry would be accepted without error, causing outgoing transactions to be signed with a key that does not match the on-chain address — resulting in fund loss or permanently rejected txs. Fix: throw an Error with a clear message so callers can detect and reject integrity failures before any funds are at risk. --- src/keystore.ts | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) 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.` ); } From 2011e4d1d4104c5ad10f999b74c697ec4572b49f Mon Sep 17 00:00:00 2001 From: AMATH <116212274+amathxbt@users.noreply.github.com> Date: Sat, 4 Jul 2026 08:12:53 +0100 Subject: [PATCH 2/5] fix(provably-fair): use rejection sampling to eliminate modulo bias (#4) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit computeDiceRoll() computed raw % 10000 on a uint32. Because 2^32 (4,294,967,296) is not evenly divisible by 10,000, values 0–7,295 appear slightly more often than values 7,296–9,999 — a systematic bias of ~1.7 per million per value in the favoured range. In a high-volume casino context this is not negligible: over millions of rolls the house retains a hidden edge on top of the declared house edge. Replace modulo with rejection sampling over successive 4-byte HMAC windows using a rejection threshold of floor(2^32 / 10000) * 10000 (4,294,960,000). Values at or above the threshold are discarded; the next 4-byte window is used. Average iterations per roll < 2. --- src/provably-fair.ts | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/src/provably-fair.ts b/src/provably-fair.ts index a60371d..bffb5b0 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; } /** @@ -83,4 +98,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 From 49d676e9f1b772f2686f79641c02bc1e50321e23 Mon Sep 17 00:00:00 2001 From: AMATH <116212274+amathxbt@users.noreply.github.com> Date: Sat, 4 Jul 2026 08:13:04 +0100 Subject: [PATCH 3/5] fix(provably-fair): add clientSeed param to computeCrashPoint (#6) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit computeCrashPoint() called computeHMAC(serverSeed, "", nonce) — always passing an empty string as the client seed. The client seed is the player-supplied entropy that lets them independently verify outcomes are not predetermined. With an empty seed, the crash point is solely a function of the server seed and nonce; the player contributes nothing and cannot verify the game was not rigged against them. Add clientSeed as a required parameter and throw if it is empty. Update the JSDoc comment accordingly. --- src/provably-fair.ts | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/provably-fair.ts b/src/provably-fair.ts index bffb5b0..23708d8 100644 --- a/src/provably-fair.ts +++ b/src/provably-fair.ts @@ -78,14 +78,22 @@ 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 From 455804001dae30a0edc11858e3fecb46a307574a Mon Sep 17 00:00:00 2001 From: AMATH <116212274+amathxbt@users.noreply.github.com> Date: Sat, 4 Jul 2026 08:13:26 +0100 Subject: [PATCH 4/5] fix(provably-fair): return 1.01 (not 1.0) for instant-crash outcome (#5) When result % 33 === 0 the function returned 1.0, but the JSDoc and the clamp at the bottom of the function both state the output range is [1.01, 100.0]. Returning 1.0 contradicts the advertised minimum and gives players a payout that is 1% worse than the published house-edge formula implies for the instant-crash case. Change the early return to 1.01 so every code path respects the advertised floor. --- src/provably-fair.ts | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/provably-fair.ts b/src/provably-fair.ts index 23708d8..f849c84 100644 --- a/src/provably-fair.ts +++ b/src/provably-fair.ts @@ -97,7 +97,11 @@ export function computeCrashPoint( 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; From b42b49a5e2f31b6a0a140caa874cfc3841d459c1 Mon Sep 17 00:00:00 2001 From: giwaov Date: Mon, 6 Jul 2026 12:08:46 +0100 Subject: [PATCH 5/5] Validate send message amount --- src/__tests__/protobuf.test.ts | 25 +++++++++++++++++++++++++ src/protobuf.ts | 9 ++++++++- 2 files changed, 33 insertions(+), 1 deletion(-) create mode 100644 src/__tests__/protobuf.test.ts diff --git a/src/__tests__/protobuf.test.ts b/src/__tests__/protobuf.test.ts new file mode 100644 index 0000000..d3ad702 --- /dev/null +++ b/src/__tests__/protobuf.test.ts @@ -0,0 +1,25 @@ +import { describe, expect, it } from "vitest"; +import { encodeMessage } from "../protobuf.js"; + +const validSend = { + fromAddress: "11".repeat(20), + toAddress: "22".repeat(20), + amount: 1, +}; + +describe("encodeMessage", () => { + it("encodes a valid send amount", () => { + const { typeUrl, msgBytes } = encodeMessage("send", validSend); + + expect(typeUrl).toBe("type.googleapis.com/types.MessageSend"); + expect(msgBytes.length).toBeGreaterThan(0); + }); + + it("rejects send amounts that cannot be encoded as uint64 values", () => { + for (const amount of [-1, 1.5, Number.NaN]) { + expect(() => encodeMessage("send", { ...validSend, amount })).toThrow( + "amount must be a non-negative safe integer", + ); + } + }); +}); \ No newline at end of file diff --git a/src/protobuf.ts b/src/protobuf.ts index c53cdee..4b505bb 100644 --- a/src/protobuf.ts +++ b/src/protobuf.ts @@ -1,6 +1,13 @@ import protobuf from "protobufjs"; import { hexToBytes } from "@noble/hashes/utils.js"; +function assertUint64Field(name: string, value: unknown): number { + if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) { + throw new Error(`${name} must be a non-negative safe integer`); + } + return value; +} + function shouldOmit(value: any): boolean { if (value === undefined || value === null) return true; if (typeof value === "string" && value === "") return true; @@ -74,7 +81,7 @@ const MESSAGE_REGISTRY: Record< MsgSend.create({ from_address: hexToBytes(msg.fromAddress), to_address: hexToBytes(msg.toAddress), - amount: msg.amount, + amount: assertUint64Field("amount", msg.amount), }) ).finish(), },