@rolly-dev/wasm-signer 1.12.0 → 1.14.0

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

@@ -2,19 +2,21 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const amount_split: (a: number, b: bigint) => void;
+export const coinflip_multiplier_x10000: () => number;
+export const coinflip_rtp_percent: () => number;
 export const compute_address_hash: (a: number, b: number, c: number) => void;
 export const compute_drawn_keno: (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_keno: (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_limbo: (a: number, b: number, c: number, d: bigint, e: 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_prediction_hash_keno: (a: number, b: number, c: number, d: number, e: number, f: 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_limbo: (a: number, b: 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;
@@ -31,6 +33,8 @@ export const seed_hash_truncated: (a: number, b: number, c: number) => void;
 export const session_public_key: (a: number, b: number, c: number, d: bigint) => void;
 export const string_to_user_seed: (a: number, b: number, c: number) => void;
 export const string_to_user_seed_hex: (a: number, b: number, c: number) => void;
+export const dice_rtp_percent: () => number;
+export const limbo_rtp_percent: () => number;
 export const goldilocks_modulus: () => bigint;
 export const __wbindgen_export: (a: number) => void;
 export const __wbindgen_add_to_stack_pointer: (a: number) => number;

package/dist/web/rolly_wasm_signer.d.ts

@@ -12,6 +12,16 @@
  */
 export function amount_split(amount: bigint): Uint32Array;
 
+/**
+ * CoinFlip multiplier × 10000 (19800 = 1.98×). Canonical source for backend/frontend.
+ */
+export function coinflip_multiplier_x10000(): number;
+
+/**
+ * CoinFlip RTP percent (99). Canonical source for backend/frontend.
+ */
+export function coinflip_rtp_percent(): number;
+
 /**
  * Compute address_hash = Poseidon2(addr_byte_0, ..., addr_byte_19).
  * Takes a hex address string (with or without 0x prefix), returns [u64; 4].
@@ -75,12 +85,11 @@ export function compute_payout_keno(random: BigUint64Array, bet_atomic: bigint,
  *
  * `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.
+ * `prediction_x100`: target multiplier x 100 (101..999999, i.e. 1.01x-9999.99x).
  *
- * Returns `BigUint64Array[4]`: `[win_amount, multiplier_x100, is_win (0|1), payout_multiplier×10000]`.
+ * Returns `BigUint64Array[4]`: `[win_amount, multiplier_x100, is_win (0|1), payout_multiplier x10000]`.
  */
-export function compute_payout_limbo(random: BigUint64Array, bet_atomic: bigint, prediction_x100: number, rtp_numer: number): BigUint64Array;
+export function compute_payout_limbo(random: BigUint64Array, bet_atomic: bigint, prediction_x100: number): BigUint64Array;
 
 /**
  * Full plinko payout computation — pure integer arithmetic, zero floats.
@@ -102,7 +111,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)`
+ *   Limbo:    `(99, prediction_x100, 0)` — RTP hardcoded at 99
  *   Dice:     `(mode, pred_lo, pred_hi)`
  *   Plinko:   `(sector, rows, is_extreme)`
  *   CoinFlip: `(prediction, 0, 0)`
@@ -135,13 +144,12 @@ 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.
+ * Extract limbo result multiplier x 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).
+ * Returns the clamped multiplier x 100 (101..999999).
  */
-export function compute_roll_limbo(random: BigUint64Array, rtp_numer: number): number;
+export function compute_roll_limbo(random: BigUint64Array): number;
 
 /**
  * Extract plinko bucket index from Poseidon2 random output.
@@ -195,6 +203,11 @@ export function compute_user_seed_binding(game_id: number, bet: bigint, pred_has
  */
 export function derive_session_key(sig_bytes: Uint8Array): BigUint64Array;
 
+/**
+ * Dice RTP percent (99). Canonical source for backend/frontend.
+ */
+export function dice_rtp_percent(): number;
+
 /**
  * Generate a cryptographically random user secret — 4 Goldilocks field elements.
  *
@@ -263,6 +276,11 @@ export function goldilocks_reduce(value: bigint): bigint;
  */
 export function hash_balance_leaf(raw: BigUint64Array): BigUint64Array;
 
+/**
+ * Limbo RTP percent (99). Canonical source for backend/frontend.
+ */
+export function limbo_rtp_percent(): number;
+
 /**
  * Build a main Merkle tree leaf from balance_hash, pk_hash, and address_hash.
  *
@@ -365,19 +383,21 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly amount_split: (a: number, b: bigint) => void;
+    readonly coinflip_multiplier_x10000: () => number;
+    readonly coinflip_rtp_percent: () => number;
     readonly compute_address_hash: (a: number, b: number, c: number) => void;
     readonly compute_drawn_keno: (a: number, b: number, c: number) => void;
     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_keno: (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_limbo: (a: number, b: number, c: number, d: bigint, e: 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_prediction_hash_keno: (a: number, b: number, c: number, d: number, e: number, f: 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_limbo: (a: number, b: 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;
@@ -394,6 +414,8 @@ export interface InitOutput {
     readonly session_public_key: (a: number, b: number, c: number, d: bigint) => void;
     readonly string_to_user_seed: (a: number, b: number, c: number) => void;
     readonly string_to_user_seed_hex: (a: number, b: number, c: number) => void;
+    readonly dice_rtp_percent: () => number;
+    readonly limbo_rtp_percent: () => number;
     readonly goldilocks_modulus: () => bigint;
     readonly __wbindgen_export: (a: number) => void;
     readonly __wbindgen_add_to_stack_pointer: (a: number) => number;

package/dist/web/rolly_wasm_signer.js

@@ -25,6 +25,24 @@ export function amount_split(amount) {
     }
 }
 
+/**
+ * CoinFlip multiplier × 10000 (19800 = 1.98×). Canonical source for backend/frontend.
+ * @returns {number}
+ */
+export function coinflip_multiplier_x10000() {
+    const ret = wasm.coinflip_multiplier_x10000();
+    return ret >>> 0;
+}
+
+/**
+ * CoinFlip RTP percent (99). Canonical source for backend/frontend.
+ * @returns {number}
+ */
+export function coinflip_rtp_percent() {
+    const ret = wasm.coinflip_rtp_percent();
+    return ret >>> 0;
+}
+
 /**
  * Compute address_hash = Poseidon2(addr_byte_0, ..., addr_byte_19).
  * Takes a hex address string (with or without 0x prefix), returns [u64; 4].
@@ -184,22 +202,20 @@ export function compute_payout_keno(random, bet_atomic, risk, selected) {
  *
  * `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.
+ * `prediction_x100`: target multiplier x 100 (101..999999, i.e. 1.01x-9999.99x).
  *
- * Returns `BigUint64Array[4]`: `[win_amount, multiplier_x100, is_win (0|1), payout_multiplier×10000]`.
+ * Returns `BigUint64Array[4]`: `[win_amount, multiplier_x100, is_win (0|1), payout_multiplier x10000]`.
  * @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) {
+export function compute_payout_limbo(random, bet_atomic, prediction_x100) {
     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);
+        wasm.compute_payout_limbo(retptr, ptr0, len0, bet_atomic, prediction_x100);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var v2 = getArrayU64FromWasm0(r0, r1).slice();
@@ -250,7 +266,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)`
+ *   Limbo:    `(99, prediction_x100, 0)` — RTP hardcoded at 99
  *   Dice:     `(mode, pred_lo, pred_hi)`
  *   Plinko:   `(sector, rows, is_extreme)`
  *   CoinFlip: `(prediction, 0, 0)`
@@ -333,19 +349,17 @@ export function compute_roll_dice(random) {
 }
 
 /**
- * Extract limbo result multiplier × 100 from Poseidon2 random output.
+ * Extract limbo result multiplier x 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).
+ * Returns the clamped multiplier x 100 (101..999999).
  * @param {BigUint64Array} random
- * @param {number} rtp_numer
  * @returns {number}
  */
-export function compute_roll_limbo(random, rtp_numer) {
+export function compute_roll_limbo(random) {
     const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.compute_roll_limbo(ptr0, len0, rtp_numer);
+    const ret = wasm.compute_roll_limbo(ptr0, len0);
     return ret >>> 0;
 }
 
@@ -462,6 +476,15 @@ export function derive_session_key(sig_bytes) {
     }
 }
 
+/**
+ * Dice RTP percent (99). Canonical source for backend/frontend.
+ * @returns {number}
+ */
+export function dice_rtp_percent() {
+    const ret = wasm.coinflip_rtp_percent();
+    return ret >>> 0;
+}
+
 /**
  * Generate a cryptographically random user secret — 4 Goldilocks field elements.
  *
@@ -603,6 +626,15 @@ export function hash_balance_leaf(raw) {
     }
 }
 
+/**
+ * Limbo RTP percent (99). Canonical source for backend/frontend.
+ * @returns {number}
+ */
+export function limbo_rtp_percent() {
+    const ret = wasm.coinflip_rtp_percent();
+    return ret >>> 0;
+}
+
 /**
  * Build a main Merkle tree leaf from balance_hash, pk_hash, and address_hash.
  *

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

@@ -2,19 +2,21 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const amount_split: (a: number, b: bigint) => void;
+export const coinflip_multiplier_x10000: () => number;
+export const coinflip_rtp_percent: () => number;
 export const compute_address_hash: (a: number, b: number, c: number) => void;
 export const compute_drawn_keno: (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_keno: (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_limbo: (a: number, b: number, c: number, d: bigint, e: 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_prediction_hash_keno: (a: number, b: number, c: number, d: number, e: number, f: 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_limbo: (a: number, b: 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;
@@ -31,6 +33,8 @@ export const seed_hash_truncated: (a: number, b: number, c: number) => void;
 export const session_public_key: (a: number, b: number, c: number, d: bigint) => void;
 export const string_to_user_seed: (a: number, b: number, c: number) => void;
 export const string_to_user_seed_hex: (a: number, b: number, c: number) => void;
+export const dice_rtp_percent: () => number;
+export const limbo_rtp_percent: () => number;
 export const goldilocks_modulus: () => bigint;
 export const __wbindgen_export: (a: number) => void;
 export const __wbindgen_add_to_stack_pointer: (a: number) => number;

package/js/browser.mjs

@@ -2,6 +2,8 @@ export { default as init } from '../dist/web/rolly_wasm_signer.js';
 
 export {
   amount_split,
+  coinflip_multiplier_x10000,
+  coinflip_rtp_percent,
   compute_address_hash,
   compute_drawn_keno,
   compute_multi_dice,
@@ -19,12 +21,14 @@ export {
   compute_server_seed_hash,
   compute_user_seed_binding,
   derive_session_key,
+  dice_rtp_percent,
   generate_user_secret,
   generate_user_seed,
   goldilocks_fields_to_hex,
   goldilocks_modulus,
   goldilocks_reduce,
   hash_balance_leaf,
+  limbo_rtp_percent,
   make_main_leaf,
   poseidon2_hash,
   poseidon2_two_to_one,

package/js/index.d.ts

@@ -1,5 +1,7 @@
 export {
   amount_split,
+  coinflip_multiplier_x10000,
+  coinflip_rtp_percent,
   compute_address_hash,
   compute_drawn_keno,
   compute_multi_dice,
@@ -17,12 +19,14 @@ export {
   compute_server_seed_hash,
   compute_user_seed_binding,
   derive_session_key,
+  dice_rtp_percent,
   generate_user_secret,
   generate_user_seed,
   goldilocks_fields_to_hex,
   goldilocks_modulus,
   goldilocks_reduce,
   hash_balance_leaf,
+  limbo_rtp_percent,
   make_main_leaf,
   poseidon2_hash,
   poseidon2_two_to_one,

package/js/node-inline.cjs

@@ -4,6 +4,8 @@ const wasm = require('../dist/node-inline/rolly_wasm_signer.js');
 
 module.exports = {
   amount_split:               wasm.amount_split,
+  coinflip_multiplier_x10000: wasm.coinflip_multiplier_x10000,
+  coinflip_rtp_percent:       wasm.coinflip_rtp_percent,
   compute_address_hash:       wasm.compute_address_hash,
   compute_drawn_keno:         wasm.compute_drawn_keno,
   compute_multi_dice:         wasm.compute_multi_dice,
@@ -21,12 +23,14 @@ module.exports = {
   compute_server_seed_hash:   wasm.compute_server_seed_hash,
   compute_user_seed_binding:  wasm.compute_user_seed_binding,
   derive_session_key:         wasm.derive_session_key,
+  dice_rtp_percent:           wasm.dice_rtp_percent,
   generate_user_secret:       wasm.generate_user_secret,
   generate_user_seed:         wasm.generate_user_seed,
   goldilocks_fields_to_hex:   wasm.goldilocks_fields_to_hex,
   goldilocks_modulus:         wasm.goldilocks_modulus,
   goldilocks_reduce:          wasm.goldilocks_reduce,
   hash_balance_leaf:          wasm.hash_balance_leaf,
+  limbo_rtp_percent:          wasm.limbo_rtp_percent,
   make_main_leaf:             wasm.make_main_leaf,
   poseidon2_hash:             wasm.poseidon2_hash,
   poseidon2_two_to_one:       wasm.poseidon2_two_to_one,

package/js/node-inline.mjs

@@ -1,5 +1,7 @@
 export {
   amount_split,
+  coinflip_multiplier_x10000,
+  coinflip_rtp_percent,
   compute_address_hash,
   compute_drawn_keno,
   compute_multi_dice,
@@ -17,12 +19,14 @@ export {
   compute_server_seed_hash,
   compute_user_seed_binding,
   derive_session_key,
+  dice_rtp_percent,
   generate_user_secret,
   generate_user_seed,
   goldilocks_fields_to_hex,
   goldilocks_modulus,
   goldilocks_reduce,
   hash_balance_leaf,
+  limbo_rtp_percent,
   make_main_leaf,
   poseidon2_hash,
   poseidon2_two_to_one,

package/js/node.cjs

@@ -4,6 +4,8 @@ const wasm = require('../dist/node/rolly_wasm_signer.js');
 
 module.exports = {
   amount_split:               wasm.amount_split,
+  coinflip_multiplier_x10000: wasm.coinflip_multiplier_x10000,
+  coinflip_rtp_percent:       wasm.coinflip_rtp_percent,
   compute_address_hash:       wasm.compute_address_hash,
   compute_drawn_keno:         wasm.compute_drawn_keno,
   compute_multi_dice:         wasm.compute_multi_dice,
@@ -21,12 +23,14 @@ module.exports = {
   compute_server_seed_hash:   wasm.compute_server_seed_hash,
   compute_user_seed_binding:  wasm.compute_user_seed_binding,
   derive_session_key:         wasm.derive_session_key,
+  dice_rtp_percent:           wasm.dice_rtp_percent,
   generate_user_secret:       wasm.generate_user_secret,
   generate_user_seed:         wasm.generate_user_seed,
   goldilocks_fields_to_hex:   wasm.goldilocks_fields_to_hex,
   goldilocks_modulus:         wasm.goldilocks_modulus,
   goldilocks_reduce:          wasm.goldilocks_reduce,
   hash_balance_leaf:          wasm.hash_balance_leaf,
+  limbo_rtp_percent:          wasm.limbo_rtp_percent,
   make_main_leaf:             wasm.make_main_leaf,
   poseidon2_hash:             wasm.poseidon2_hash,
   poseidon2_two_to_one:       wasm.poseidon2_two_to_one,

package/js/node.mjs

@@ -5,6 +5,8 @@ const wasm = require('../dist/node/rolly_wasm_signer.js');
 
 export const {
   amount_split,
+  coinflip_multiplier_x10000,
+  coinflip_rtp_percent,
   compute_address_hash,
   compute_drawn_keno,
   compute_multi_dice,
@@ -22,12 +24,14 @@ export const {
   compute_server_seed_hash,
   compute_user_seed_binding,
   derive_session_key,
+  dice_rtp_percent,
   generate_user_secret,
   generate_user_seed,
   goldilocks_fields_to_hex,
   goldilocks_modulus,
   goldilocks_reduce,
   hash_balance_leaf,
+  limbo_rtp_percent,
   make_main_leaf,
   poseidon2_hash,
   poseidon2_two_to_one,

package/js/react.mjs

@@ -1,6 +1,8 @@
 import { useState, useEffect } from 'react';
 import init, {
   amount_split,
+  coinflip_multiplier_x10000,
+  coinflip_rtp_percent,
   compute_address_hash,
   compute_drawn_keno,
   compute_multi_dice,
@@ -18,12 +20,14 @@ import init, {
   compute_server_seed_hash,
   compute_user_seed_binding,
   derive_session_key,
+  dice_rtp_percent,
   generate_user_secret,
   generate_user_seed,
   goldilocks_fields_to_hex,
   goldilocks_modulus,
   goldilocks_reduce,
   hash_balance_leaf,
+  limbo_rtp_percent,
   make_main_leaf,
   poseidon2_hash,
   poseidon2_two_to_one,
@@ -45,6 +49,8 @@ function guard(fn) {
 
 const fns = {
   amount_split:               guard(amount_split),
+  coinflip_multiplier_x10000: guard(coinflip_multiplier_x10000),
+  coinflip_rtp_percent:       guard(coinflip_rtp_percent),
   compute_address_hash:       guard(compute_address_hash),
   compute_drawn_keno:         guard(compute_drawn_keno),
   compute_multi_dice:         guard(compute_multi_dice),
@@ -62,12 +68,14 @@ const fns = {
   compute_server_seed_hash:   guard(compute_server_seed_hash),
   compute_user_seed_binding:  guard(compute_user_seed_binding),
   derive_session_key:         guard(derive_session_key),
+  dice_rtp_percent:           guard(dice_rtp_percent),
   generate_user_secret:       guard(generate_user_secret),
   generate_user_seed:         guard(generate_user_seed),
   goldilocks_fields_to_hex:   guard(goldilocks_fields_to_hex),
   goldilocks_modulus:         guard(goldilocks_modulus),
   goldilocks_reduce:          guard(goldilocks_reduce),
   hash_balance_leaf:          guard(hash_balance_leaf),
+  limbo_rtp_percent:          guard(limbo_rtp_percent),
   make_main_leaf:             guard(make_main_leaf),
   poseidon2_hash:             guard(poseidon2_hash),
   poseidon2_two_to_one:       guard(poseidon2_two_to_one),

package/package.json

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