@rolly-dev/wasm-signer 1.0.0 → 1.1.0

package/README.md

@@ -107,6 +107,42 @@ module.exports = { experiments: { asyncWebAssembly: true } };
 
 **Next.js** — conditional exports auto-resolve: Node.js entry on server, browser entry on client.
 
+## Dice — range constraints
+
+Roll number: `[0, 999]` (TOTAL_RANGE = 1000).
+win_numbers (wn): `[1, 950]` (MIN_RANGE..=MAX_RANGE).
+
+### prediction_range constraints per mode
+
+| Mode  | wn formula                                     | prediction\[0\] | prediction\[1\] | wn range   |
+|-------|-------------------------------------------------|-----------------|-----------------|------------|
+| Under | `prediction[0]`                                 | `[1, 950]`      | unused (0)      | `[1, 950]` |
+| Over  | `999 − prediction[0]`                           | `[49, 998]`     | unused (0)      | `[1, 950]` |
+| In    | `prediction[1] − prediction[0] + 1`             | `[0, 999]`      | `[0, 999]`      | `[1, 950]` |
+| Out   | `1000 − (prediction[1] − prediction[0] + 1)`    | `[0, 999]`      | `[0, 999]`      | `[1, 950]` |
+
+**Under** — `prediction[0]` ∈ `[1, 950]` (= wn directly). Win: `roll < prediction[0]`.
+
+**Over** — `prediction[0]` ∈ `[49, 998]` (lower: `999 − 950 = 49`, upper: `999 − 1 = 998`). Win: `roll > prediction[0]`.
+
+**In** — `prediction[0] <= prediction[1]`, span ∈ `[1, 950]`. Win: `prediction[0] <= roll <= prediction[1]`.
+
+**Out** — `prediction[0] <= prediction[1]`, inner span ∈ `[50, 999]` (wn = `1000 − inner` ∈ `[1, 950]`). Win: `roll < prediction[0] || roll > prediction[1]`.
+
+### Multiplier
+
+`multiplier = floor(9_900_000 / wn)` (scaled ×10000).
+
+| wn  | multiplier | display   |
+|-----|-----------|-----------|
+| 1   | 9_900_000 | 990.0000x |
+| 500 | 19_800    | 1.9800x   |
+| 950 | 10_421    | 1.0421x   |
+
+### RTP
+
+Theoretical: **98.998%** (floor-division costs ~0.002%). House edge: **~1.002%**. Max win cap: 10,000 USDT (business rule, not formula).
+
 ## License
 
 MIT

package/dist/node/README.md

@@ -107,6 +107,42 @@ module.exports = { experiments: { asyncWebAssembly: true } };
 
 **Next.js** — conditional exports auto-resolve: Node.js entry on server, browser entry on client.
 
+## Dice — range constraints
+
+Roll number: `[0, 999]` (TOTAL_RANGE = 1000).
+win_numbers (wn): `[1, 950]` (MIN_RANGE..=MAX_RANGE).
+
+### prediction_range constraints per mode
+
+| Mode  | wn formula                                     | prediction\[0\] | prediction\[1\] | wn range   |
+|-------|-------------------------------------------------|-----------------|-----------------|------------|
+| Under | `prediction[0]`                                 | `[1, 950]`      | unused (0)      | `[1, 950]` |
+| Over  | `999 − prediction[0]`                           | `[49, 998]`     | unused (0)      | `[1, 950]` |
+| In    | `prediction[1] − prediction[0] + 1`             | `[0, 999]`      | `[0, 999]`      | `[1, 950]` |
+| Out   | `1000 − (prediction[1] − prediction[0] + 1)`    | `[0, 999]`      | `[0, 999]`      | `[1, 950]` |
+
+**Under** — `prediction[0]` ∈ `[1, 950]` (= wn directly). Win: `roll < prediction[0]`.
+
+**Over** — `prediction[0]` ∈ `[49, 998]` (lower: `999 − 950 = 49`, upper: `999 − 1 = 998`). Win: `roll > prediction[0]`.
+
+**In** — `prediction[0] <= prediction[1]`, span ∈ `[1, 950]`. Win: `prediction[0] <= roll <= prediction[1]`.
+
+**Out** — `prediction[0] <= prediction[1]`, inner span ∈ `[50, 999]` (wn = `1000 − inner` ∈ `[1, 950]`). Win: `roll < prediction[0] || roll > prediction[1]`.
+
+### Multiplier
+
+`multiplier = floor(9_900_000 / wn)` (scaled ×10000).
+
+| wn  | multiplier | display   |
+|-----|-----------|-----------|
+| 1   | 9_900_000 | 990.0000x |
+| 500 | 19_800    | 1.9800x   |
+| 950 | 10_421    | 1.0421x   |
+
+### RTP
+
+Theoretical: **98.998%** (floor-division costs ~0.002%). House edge: **~1.002%**. Max win cap: 10,000 USDT (business rule, not formula).
+
 ## License
 
 MIT

package/dist/node/rolly_wasm_signer.d.ts

@@ -18,6 +18,33 @@ export function amount_split(amount: bigint): Uint32Array;
  */
 export function compute_address_hash(address_hex: string): BigUint64Array;
 
+/**
+ * Compute dice multiplier × 10000 from win_numbers count.
+ *
+ * Formula: `9_900_000 / win_numbers` (integer division = floor).
+ * `win_numbers` must be in [1, 950].
+ */
+export function compute_multi_dice(win_numbers: number): bigint;
+
+/**
+ * Full dice payout computation — pure integer arithmetic, zero floats.
+ *
+ * `random`: 4 Goldilocks field elements (Poseidon2 output).
+ * `bet_atomic`: bet in atomic units (1 USDT = 1_000_000).
+ * `game_mode`: 0=Under, 1=Over, 2=In, 3=Out.
+ * `prediction_lo` / `prediction_hi`: prediction range bounds (0..999).
+ *
+ * Returns `BigUint64Array[4]`: `[win_amount, roll_number, is_win (0|1), multiplier×10000]`.
+ */
+export function compute_payout_dice(random: BigUint64Array, bet_atomic: bigint, game_mode: number, prediction_lo: number, prediction_hi: number): BigUint64Array;
+
+/**
+ * Extract dice roll number [0, 1000) from Poseidon2 random output.
+ *
+ * `random` must be exactly 4 elements. Returns `random[0] % 1000`.
+ */
+export function compute_roll_dice(random: BigUint64Array): number;
+
 /**
  * Full Poseidon2 hash of an 8-element server seed.
  *

package/dist/node/rolly_wasm_signer.js

@@ -49,6 +49,68 @@ function compute_address_hash(address_hex) {
 }
 exports.compute_address_hash = compute_address_hash;
 
+/**
+ * Compute dice multiplier × 10000 from win_numbers count.
+ *
+ * Formula: `9_900_000 / win_numbers` (integer division = floor).
+ * `win_numbers` must be in [1, 950].
+ * @param {number} win_numbers
+ * @returns {bigint}
+ */
+function compute_multi_dice(win_numbers) {
+    const ret = wasm.compute_multi_dice(win_numbers);
+    return BigInt.asUintN(64, ret);
+}
+exports.compute_multi_dice = compute_multi_dice;
+
+/**
+ * Full dice payout computation — pure integer arithmetic, zero floats.
+ *
+ * `random`: 4 Goldilocks field elements (Poseidon2 output).
+ * `bet_atomic`: bet in atomic units (1 USDT = 1_000_000).
+ * `game_mode`: 0=Under, 1=Over, 2=In, 3=Out.
+ * `prediction_lo` / `prediction_hi`: prediction range bounds (0..999).
+ *
+ * Returns `BigUint64Array[4]`: `[win_amount, roll_number, is_win (0|1), multiplier×10000]`.
+ * @param {BigUint64Array} random
+ * @param {bigint} bet_atomic
+ * @param {number} game_mode
+ * @param {number} prediction_lo
+ * @param {number} prediction_hi
+ * @returns {BigUint64Array}
+ */
+function compute_payout_dice(random, bet_atomic, game_mode, prediction_lo, prediction_hi) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.compute_payout_dice(retptr, ptr0, len0, bet_atomic, game_mode, prediction_lo, prediction_hi);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var v2 = getArrayU64FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export2(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.compute_payout_dice = compute_payout_dice;
+
+/**
+ * Extract dice roll number [0, 1000) from Poseidon2 random output.
+ *
+ * `random` must be exactly 4 elements. Returns `random[0] % 1000`.
+ * @param {BigUint64Array} random
+ * @returns {number}
+ */
+function compute_roll_dice(random) {
+    const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.compute_roll_dice(ptr0, len0);
+    return ret >>> 0;
+}
+exports.compute_roll_dice = compute_roll_dice;
+
 /**
  * Full Poseidon2 hash of an 8-element server seed.
  *

package/dist/node/rolly_wasm_signer_bg.wasm.d.ts

@@ -3,6 +3,9 @@
 export const memory: WebAssembly.Memory;
 export const amount_split: (a: number, b: bigint) => void;
 export const compute_address_hash: (a: number, b: number, c: number) => void;
+export const compute_multi_dice: (a: number) => bigint;
+export const compute_payout_dice: (a: number, b: number, c: number, d: bigint, e: number, f: number, g: number) => void;
+export const compute_roll_dice: (a: number, b: number) => number;
 export const compute_server_seed_hash: (a: number, b: number, c: number) => void;
 export const derive_session_key: (a: number, b: number, c: number) => void;
 export const generate_user_seed: (a: number) => void;

package/dist/node-inline/README.md

@@ -107,6 +107,42 @@ module.exports = { experiments: { asyncWebAssembly: true } };
 
 **Next.js** — conditional exports auto-resolve: Node.js entry on server, browser entry on client.
 
+## Dice — range constraints
+
+Roll number: `[0, 999]` (TOTAL_RANGE = 1000).
+win_numbers (wn): `[1, 950]` (MIN_RANGE..=MAX_RANGE).
+
+### prediction_range constraints per mode
+
+| Mode  | wn formula                                     | prediction\[0\] | prediction\[1\] | wn range   |
+|-------|-------------------------------------------------|-----------------|-----------------|------------|
+| Under | `prediction[0]`                                 | `[1, 950]`      | unused (0)      | `[1, 950]` |
+| Over  | `999 − prediction[0]`                           | `[49, 998]`     | unused (0)      | `[1, 950]` |
+| In    | `prediction[1] − prediction[0] + 1`             | `[0, 999]`      | `[0, 999]`      | `[1, 950]` |
+| Out   | `1000 − (prediction[1] − prediction[0] + 1)`    | `[0, 999]`      | `[0, 999]`      | `[1, 950]` |
+
+**Under** — `prediction[0]` ∈ `[1, 950]` (= wn directly). Win: `roll < prediction[0]`.
+
+**Over** — `prediction[0]` ∈ `[49, 998]` (lower: `999 − 950 = 49`, upper: `999 − 1 = 998`). Win: `roll > prediction[0]`.
+
+**In** — `prediction[0] <= prediction[1]`, span ∈ `[1, 950]`. Win: `prediction[0] <= roll <= prediction[1]`.
+
+**Out** — `prediction[0] <= prediction[1]`, inner span ∈ `[50, 999]` (wn = `1000 − inner` ∈ `[1, 950]`). Win: `roll < prediction[0] || roll > prediction[1]`.
+
+### Multiplier
+
+`multiplier = floor(9_900_000 / wn)` (scaled ×10000).
+
+| wn  | multiplier | display   |
+|-----|-----------|-----------|
+| 1   | 9_900_000 | 990.0000x |
+| 500 | 19_800    | 1.9800x   |
+| 950 | 10_421    | 1.0421x   |
+
+### RTP
+
+Theoretical: **98.998%** (floor-division costs ~0.002%). House edge: **~1.002%**. Max win cap: 10,000 USDT (business rule, not formula).
+
 ## License
 
 MIT

package/dist/node-inline/rolly_wasm_signer.d.ts

@@ -18,6 +18,33 @@ export function amount_split(amount: bigint): Uint32Array;
  */
 export function compute_address_hash(address_hex: string): BigUint64Array;
 
+/**
+ * Compute dice multiplier × 10000 from win_numbers count.
+ *
+ * Formula: `9_900_000 / win_numbers` (integer division = floor).
+ * `win_numbers` must be in [1, 950].
+ */
+export function compute_multi_dice(win_numbers: number): bigint;
+
+/**
+ * Full dice payout computation — pure integer arithmetic, zero floats.
+ *
+ * `random`: 4 Goldilocks field elements (Poseidon2 output).
+ * `bet_atomic`: bet in atomic units (1 USDT = 1_000_000).
+ * `game_mode`: 0=Under, 1=Over, 2=In, 3=Out.
+ * `prediction_lo` / `prediction_hi`: prediction range bounds (0..999).
+ *
+ * Returns `BigUint64Array[4]`: `[win_amount, roll_number, is_win (0|1), multiplier×10000]`.
+ */
+export function compute_payout_dice(random: BigUint64Array, bet_atomic: bigint, game_mode: number, prediction_lo: number, prediction_hi: number): BigUint64Array;
+
+/**
+ * Extract dice roll number [0, 1000) from Poseidon2 random output.
+ *
+ * `random` must be exactly 4 elements. Returns `random[0] % 1000`.
+ */
+export function compute_roll_dice(random: BigUint64Array): number;
+
 /**
  * Full Poseidon2 hash of an 8-element server seed.
  *