@rolly-dev/wasm-signer 1.9.0 → 1.11.0

package/dist/web/rolly_wasm_signer.d.ts

@@ -49,6 +49,18 @@ export function compute_payout_coinflip(random: BigUint64Array, bet_atomic: bigi
  */
 export function compute_payout_dice(random: BigUint64Array, bet_atomic: bigint, game_mode: number, prediction_lo: number, prediction_hi: number): BigUint64Array;
 
+/**
+ * Full limbo 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).
+ * `prediction_x100`: target multiplier × 100 (101..999999, i.e. 1.01x–9999.99x).
+ * `rtp_numer`: RTP numerator for this bet (90–99). Stored per-bet, included in prediction_hash.
+ *
+ * Returns `BigUint64Array[4]`: `[win_amount, multiplier_x100, is_win (0|1), payout_multiplier×10000]`.
+ */
+export function compute_payout_limbo(random: BigUint64Array, bet_atomic: bigint, prediction_x100: number, rtp_numer: number): BigUint64Array;
+
 /**
  * Full plinko payout computation — pure integer arithmetic, zero floats.
  *
@@ -69,6 +81,7 @@ export function compute_payout_plinko(random: BigUint64Array, bet_atomic: bigint
  * and the in-circuit `build_prediction_hash`.
  *
  * Semantics of p0–p2 depend on the game:
+ *   Limbo:    `(rtp_numer, prediction_x100, 0)`
  *   Dice:     `(mode, pred_lo, pred_hi)`
  *   Plinko:   `(sector, rows, is_extreme)`
  *   CoinFlip: `(prediction, 0, 0)`
@@ -89,6 +102,15 @@ export function compute_roll_coinflip(random: BigUint64Array): number;
  */
 export function compute_roll_dice(random: BigUint64Array): number;
 
+/**
+ * Extract limbo result multiplier × 100 from Poseidon2 random output.
+ *
+ * `random` must be exactly 4 elements.
+ * `rtp_numer` must be in [90, 99].
+ * Returns the clamped multiplier × 100 (101..999999).
+ */
+export function compute_roll_limbo(random: BigUint64Array, rtp_numer: number): number;
+
 /**
  * Extract plinko bucket index from Poseidon2 random output.
  *
@@ -315,10 +337,12 @@ export interface InitOutput {
     readonly compute_multi_dice: (a: number) => bigint;
     readonly compute_payout_coinflip: (a: number, b: number, c: number, d: bigint, e: number) => void;
     readonly compute_payout_dice: (a: number, b: number, c: number, d: bigint, e: number, f: number, g: number) => void;
+    readonly compute_payout_limbo: (a: number, b: number, c: number, d: bigint, e: number, f: number) => void;
     readonly compute_payout_plinko: (a: number, b: number, c: number, d: bigint, e: number, f: number, g: number) => void;
     readonly compute_prediction_hash: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly compute_roll_coinflip: (a: number, b: number) => number;
     readonly compute_roll_dice: (a: number, b: number) => number;
+    readonly compute_roll_limbo: (a: number, b: number, c: number) => number;
     readonly compute_roll_plinko: (a: number, b: number, c: number) => number;
     readonly compute_server_seed_hash: (a: number, b: number, c: number) => void;
     readonly compute_user_seed_binding: (a: number, b: number, c: bigint, d: number, e: number, f: number, g: number) => void;

package/dist/web/rolly_wasm_signer.js

@@ -121,6 +121,37 @@ export function compute_payout_dice(random, bet_atomic, game_mode, prediction_lo
     }
 }
 
+/**
+ * Full limbo 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).
+ * `prediction_x100`: target multiplier × 100 (101..999999, i.e. 1.01x–9999.99x).
+ * `rtp_numer`: RTP numerator for this bet (90–99). Stored per-bet, included in prediction_hash.
+ *
+ * Returns `BigUint64Array[4]`: `[win_amount, multiplier_x100, is_win (0|1), payout_multiplier×10000]`.
+ * @param {BigUint64Array} random
+ * @param {bigint} bet_atomic
+ * @param {number} prediction_x100
+ * @param {number} rtp_numer
+ * @returns {BigUint64Array}
+ */
+export function compute_payout_limbo(random, bet_atomic, prediction_x100, rtp_numer) {
+    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_limbo(retptr, ptr0, len0, bet_atomic, prediction_x100, rtp_numer);
+        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);
+    }
+}
+
 /**
  * Full plinko payout computation — pure integer arithmetic, zero floats.
  *
@@ -161,6 +192,7 @@ export function compute_payout_plinko(random, bet_atomic, sector, rows, is_extre
  * and the in-circuit `build_prediction_hash`.
  *
  * Semantics of p0–p2 depend on the game:
+ *   Limbo:    `(rtp_numer, prediction_x100, 0)`
  *   Dice:     `(mode, pred_lo, pred_hi)`
  *   Plinko:   `(sector, rows, is_extreme)`
  *   CoinFlip: `(prediction, 0, 0)`
@@ -212,6 +244,23 @@ export function compute_roll_dice(random) {
     return ret >>> 0;
 }
 
+/**
+ * Extract limbo result multiplier × 100 from Poseidon2 random output.
+ *
+ * `random` must be exactly 4 elements.
+ * `rtp_numer` must be in [90, 99].
+ * Returns the clamped multiplier × 100 (101..999999).
+ * @param {BigUint64Array} random
+ * @param {number} rtp_numer
+ * @returns {number}
+ */
+export function compute_roll_limbo(random, rtp_numer) {
+    const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.compute_roll_limbo(ptr0, len0, rtp_numer);
+    return ret >>> 0;
+}
+
 /**
  * Extract plinko bucket index from Poseidon2 random output.
  *

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

@@ -6,10 +6,12 @@ export const compute_address_hash: (a: number, b: number, c: number) => void;
 export const compute_multi_dice: (a: number) => bigint;
 export const compute_payout_coinflip: (a: number, b: number, c: number, d: bigint, e: number) => void;
 export const compute_payout_dice: (a: number, b: number, c: number, d: bigint, e: number, f: number, g: number) => void;
+export const compute_payout_limbo: (a: number, b: number, c: number, d: bigint, e: number, f: number) => void;
 export const compute_payout_plinko: (a: number, b: number, c: number, d: bigint, e: number, f: number, g: number) => void;
 export const compute_prediction_hash: (a: number, b: number, c: number, d: number, e: number) => void;
 export const compute_roll_coinflip: (a: number, b: number) => number;
 export const compute_roll_dice: (a: number, b: number) => number;
+export const compute_roll_limbo: (a: number, b: number, c: number) => number;
 export const compute_roll_plinko: (a: number, b: number, c: number) => number;
 export const compute_server_seed_hash: (a: number, b: number, c: number) => void;
 export const compute_user_seed_binding: (a: number, b: number, c: bigint, d: number, e: number, f: number, g: number) => void;

package/js/browser.mjs

@@ -6,10 +6,12 @@ export {
   compute_multi_dice,
   compute_payout_coinflip,
   compute_payout_dice,
+  compute_payout_limbo,
   compute_payout_plinko,
   compute_prediction_hash,
   compute_roll_coinflip,
   compute_roll_dice,
+  compute_roll_limbo,
   compute_roll_plinko,
   compute_server_seed_hash,
   compute_user_seed_binding,

package/js/index.d.ts

@@ -4,10 +4,12 @@ export {
   compute_multi_dice,
   compute_payout_coinflip,
   compute_payout_dice,
+  compute_payout_limbo,
   compute_payout_plinko,
   compute_prediction_hash,
   compute_roll_coinflip,
   compute_roll_dice,
+  compute_roll_limbo,
   compute_roll_plinko,
   compute_server_seed_hash,
   compute_user_seed_binding,

package/js/node-inline.cjs

@@ -8,10 +8,12 @@ module.exports = {
   compute_multi_dice:         wasm.compute_multi_dice,
   compute_payout_coinflip:    wasm.compute_payout_coinflip,
   compute_payout_dice:        wasm.compute_payout_dice,
+  compute_payout_limbo:       wasm.compute_payout_limbo,
   compute_payout_plinko:      wasm.compute_payout_plinko,
   compute_prediction_hash:    wasm.compute_prediction_hash,
   compute_roll_coinflip:      wasm.compute_roll_coinflip,
   compute_roll_dice:          wasm.compute_roll_dice,
+  compute_roll_limbo:         wasm.compute_roll_limbo,
   compute_roll_plinko:        wasm.compute_roll_plinko,
   compute_server_seed_hash:   wasm.compute_server_seed_hash,
   compute_user_seed_binding:  wasm.compute_user_seed_binding,

package/js/node-inline.mjs

@@ -4,10 +4,12 @@ export {
   compute_multi_dice,
   compute_payout_coinflip,
   compute_payout_dice,
+  compute_payout_limbo,
   compute_payout_plinko,
   compute_prediction_hash,
   compute_roll_coinflip,
   compute_roll_dice,
+  compute_roll_limbo,
   compute_roll_plinko,
   compute_server_seed_hash,
   compute_user_seed_binding,

package/js/node.cjs

@@ -8,10 +8,12 @@ module.exports = {
   compute_multi_dice:         wasm.compute_multi_dice,
   compute_payout_coinflip:    wasm.compute_payout_coinflip,
   compute_payout_dice:        wasm.compute_payout_dice,
+  compute_payout_limbo:       wasm.compute_payout_limbo,
   compute_payout_plinko:      wasm.compute_payout_plinko,
   compute_prediction_hash:    wasm.compute_prediction_hash,
   compute_roll_coinflip:      wasm.compute_roll_coinflip,
   compute_roll_dice:          wasm.compute_roll_dice,
+  compute_roll_limbo:         wasm.compute_roll_limbo,
   compute_roll_plinko:        wasm.compute_roll_plinko,
   compute_server_seed_hash:   wasm.compute_server_seed_hash,
   compute_user_seed_binding:  wasm.compute_user_seed_binding,

package/js/node.mjs

@@ -9,10 +9,12 @@ export const {
   compute_multi_dice,
   compute_payout_coinflip,
   compute_payout_dice,
+  compute_payout_limbo,
   compute_payout_plinko,
   compute_prediction_hash,
   compute_roll_coinflip,
   compute_roll_dice,
+  compute_roll_limbo,
   compute_roll_plinko,
   compute_server_seed_hash,
   compute_user_seed_binding,

package/js/react.mjs

@@ -5,10 +5,12 @@ import init, {
   compute_multi_dice,
   compute_payout_coinflip,
   compute_payout_dice,
+  compute_payout_limbo,
   compute_payout_plinko,
   compute_prediction_hash,
   compute_roll_coinflip,
   compute_roll_dice,
+  compute_roll_limbo,
   compute_roll_plinko,
   compute_server_seed_hash,
   compute_user_seed_binding,
@@ -44,10 +46,12 @@ const fns = {
   compute_multi_dice:         guard(compute_multi_dice),
   compute_payout_coinflip:    guard(compute_payout_coinflip),
   compute_payout_dice:        guard(compute_payout_dice),
+  compute_payout_limbo:       guard(compute_payout_limbo),
   compute_payout_plinko:      guard(compute_payout_plinko),
   compute_prediction_hash:    guard(compute_prediction_hash),
   compute_roll_coinflip:      guard(compute_roll_coinflip),
   compute_roll_dice:          guard(compute_roll_dice),
+  compute_roll_limbo:         guard(compute_roll_limbo),
   compute_roll_plinko:        guard(compute_roll_plinko),
   compute_server_seed_hash:   guard(compute_server_seed_hash),
   compute_user_seed_binding:  guard(compute_user_seed_binding),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rolly-dev/wasm-signer",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "Poseidon2 hashing & bet signing for Rolly ZK-Rollup (WASM, Goldilocks field)",
   "type": "module",
   "exports": {