@rolly-dev/wasm-signer 1.11.0 → 1.12.0

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

@@ -3,12 +3,15 @@
 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_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_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;

package/dist/web/rolly_wasm_signer.d.ts

@@ -18,6 +18,15 @@ export function amount_split(amount: bigint): Uint32Array;
  */
 export function compute_address_hash(address_hex: string): BigUint64Array;
 
+/**
+ * Extract the 10 drawn numbers from Poseidon2 random output using
+ * the combinatorial number system: `combo_index = random[0] % C(40,10)`.
+ *
+ * `random` must be exactly 4 elements.
+ * Returns `Uint8Array` of length 10 (sorted ascending, each in [0, 39]).
+ */
+export function compute_drawn_keno(random: BigUint64Array): Uint8Array;
+
 /**
  * Compute dice multiplier × 10000 from win_numbers count.
  *
@@ -49,6 +58,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 keno 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).
+ * `risk`: 0=low, 1=medium, 2=high.
+ * `selected`: player-chosen numbers (0-indexed, each in [0, 39]).
+ *
+ * Returns `BigUint64Array[4]`: `[win_amount, match_count, is_win (0|1), multiplier×10000]`.
+ */
+export function compute_payout_keno(random: BigUint64Array, bet_atomic: bigint, risk: number, selected: Uint8Array): BigUint64Array;
+
 /**
  * Full limbo payout computation — pure integer arithmetic, zero floats.
  *
@@ -88,6 +109,17 @@ export function compute_payout_plinko(random: BigUint64Array, bet_atomic: bigint
  */
 export function compute_prediction_hash(game_id: number, p0: number, p1: number, p2: number): BigUint64Array;
 
+/**
+ * Compute Keno prediction hash with extended 13-input format:
+ * `Poseidon2(game_id, risk, pick_count, selected[0], …, selected[9])`.
+ *
+ * Selected numbers are sorted internally for deterministic output.
+ * Unused slots (when pick_count < 10) are filled with 0.
+ *
+ * Returns `BigUint64Array` of length 4 (one `HashOut`).
+ */
+export function compute_prediction_hash_keno(game_id: number, risk: number, pick_count: number, selected: Uint8Array): BigUint64Array;
+
 /**
  * Extract coinflip roll (0 or 1) from Poseidon2 random output.
  *
@@ -334,12 +366,15 @@ export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly amount_split: (a: number, b: bigint) => void;
     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_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;

package/dist/web/rolly_wasm_signer.js

@@ -47,6 +47,31 @@ export function compute_address_hash(address_hex) {
     }
 }
 
+/**
+ * Extract the 10 drawn numbers from Poseidon2 random output using
+ * the combinatorial number system: `combo_index = random[0] % C(40,10)`.
+ *
+ * `random` must be exactly 4 elements.
+ * Returns `Uint8Array` of length 10 (sorted ascending, each in [0, 39]).
+ * @param {BigUint64Array} random
+ * @returns {Uint8Array}
+ */
+export function compute_drawn_keno(random) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.compute_drawn_keno(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export2(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Compute dice multiplier × 10000 from win_numbers count.
  *
@@ -121,6 +146,39 @@ export function compute_payout_dice(random, bet_atomic, game_mode, prediction_lo
     }
 }
 
+/**
+ * Full keno 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).
+ * `risk`: 0=low, 1=medium, 2=high.
+ * `selected`: player-chosen numbers (0-indexed, each in [0, 39]).
+ *
+ * Returns `BigUint64Array[4]`: `[win_amount, match_count, is_win (0|1), multiplier×10000]`.
+ * @param {BigUint64Array} random
+ * @param {bigint} bet_atomic
+ * @param {number} risk
+ * @param {Uint8Array} selected
+ * @returns {BigUint64Array}
+ */
+export function compute_payout_keno(random, bet_atomic, risk, selected) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray64ToWasm0(random, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(selected, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.compute_payout_keno(retptr, ptr0, len0, bet_atomic, risk, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var v3 = getArrayU64FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export2(r0, r1 * 8, 8);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Full limbo payout computation — pure integer arithmetic, zero floats.
  *
@@ -216,6 +274,36 @@ export function compute_prediction_hash(game_id, p0, p1, p2) {
     }
 }
 
+/**
+ * Compute Keno prediction hash with extended 13-input format:
+ * `Poseidon2(game_id, risk, pick_count, selected[0], …, selected[9])`.
+ *
+ * Selected numbers are sorted internally for deterministic output.
+ * Unused slots (when pick_count < 10) are filled with 0.
+ *
+ * Returns `BigUint64Array` of length 4 (one `HashOut`).
+ * @param {number} game_id
+ * @param {number} risk
+ * @param {number} pick_count
+ * @param {Uint8Array} selected
+ * @returns {BigUint64Array}
+ */
+export function compute_prediction_hash_keno(game_id, risk, pick_count, selected) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(selected, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.compute_prediction_hash_keno(retptr, game_id, risk, pick_count, ptr0, len0);
+        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);
+    }
+}
+
 /**
  * Extract coinflip roll (0 or 1) from Poseidon2 random output.
  *

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

@@ -3,12 +3,15 @@
 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_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_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;

package/js/browser.mjs

@@ -3,12 +3,15 @@ export { default as init } from '../dist/web/rolly_wasm_signer.js';
 export {
   amount_split,
   compute_address_hash,
+  compute_drawn_keno,
   compute_multi_dice,
   compute_payout_coinflip,
   compute_payout_dice,
+  compute_payout_keno,
   compute_payout_limbo,
   compute_payout_plinko,
   compute_prediction_hash,
+  compute_prediction_hash_keno,
   compute_roll_coinflip,
   compute_roll_dice,
   compute_roll_limbo,

package/js/index.d.ts

@@ -1,12 +1,15 @@
 export {
   amount_split,
   compute_address_hash,
+  compute_drawn_keno,
   compute_multi_dice,
   compute_payout_coinflip,
   compute_payout_dice,
+  compute_payout_keno,
   compute_payout_limbo,
   compute_payout_plinko,
   compute_prediction_hash,
+  compute_prediction_hash_keno,
   compute_roll_coinflip,
   compute_roll_dice,
   compute_roll_limbo,

package/js/node-inline.cjs

@@ -5,12 +5,15 @@ const wasm = require('../dist/node-inline/rolly_wasm_signer.js');
 module.exports = {
   amount_split:               wasm.amount_split,
   compute_address_hash:       wasm.compute_address_hash,
+  compute_drawn_keno:         wasm.compute_drawn_keno,
   compute_multi_dice:         wasm.compute_multi_dice,
   compute_payout_coinflip:    wasm.compute_payout_coinflip,
   compute_payout_dice:        wasm.compute_payout_dice,
+  compute_payout_keno:        wasm.compute_payout_keno,
   compute_payout_limbo:       wasm.compute_payout_limbo,
   compute_payout_plinko:      wasm.compute_payout_plinko,
   compute_prediction_hash:    wasm.compute_prediction_hash,
+  compute_prediction_hash_keno:wasm.compute_prediction_hash_keno,
   compute_roll_coinflip:      wasm.compute_roll_coinflip,
   compute_roll_dice:          wasm.compute_roll_dice,
   compute_roll_limbo:         wasm.compute_roll_limbo,

package/js/node-inline.mjs

@@ -1,12 +1,15 @@
 export {
   amount_split,
   compute_address_hash,
+  compute_drawn_keno,
   compute_multi_dice,
   compute_payout_coinflip,
   compute_payout_dice,
+  compute_payout_keno,
   compute_payout_limbo,
   compute_payout_plinko,
   compute_prediction_hash,
+  compute_prediction_hash_keno,
   compute_roll_coinflip,
   compute_roll_dice,
   compute_roll_limbo,

package/js/node.cjs

@@ -5,12 +5,15 @@ const wasm = require('../dist/node/rolly_wasm_signer.js');
 module.exports = {
   amount_split:               wasm.amount_split,
   compute_address_hash:       wasm.compute_address_hash,
+  compute_drawn_keno:         wasm.compute_drawn_keno,
   compute_multi_dice:         wasm.compute_multi_dice,
   compute_payout_coinflip:    wasm.compute_payout_coinflip,
   compute_payout_dice:        wasm.compute_payout_dice,
+  compute_payout_keno:        wasm.compute_payout_keno,
   compute_payout_limbo:       wasm.compute_payout_limbo,
   compute_payout_plinko:      wasm.compute_payout_plinko,
   compute_prediction_hash:    wasm.compute_prediction_hash,
+  compute_prediction_hash_keno:wasm.compute_prediction_hash_keno,
   compute_roll_coinflip:      wasm.compute_roll_coinflip,
   compute_roll_dice:          wasm.compute_roll_dice,
   compute_roll_limbo:         wasm.compute_roll_limbo,

package/js/node.mjs

@@ -6,12 +6,15 @@ const wasm = require('../dist/node/rolly_wasm_signer.js');
 export const {
   amount_split,
   compute_address_hash,
+  compute_drawn_keno,
   compute_multi_dice,
   compute_payout_coinflip,
   compute_payout_dice,
+  compute_payout_keno,
   compute_payout_limbo,
   compute_payout_plinko,
   compute_prediction_hash,
+  compute_prediction_hash_keno,
   compute_roll_coinflip,
   compute_roll_dice,
   compute_roll_limbo,

package/js/react.mjs

@@ -2,12 +2,15 @@ import { useState, useEffect } from 'react';
 import init, {
   amount_split,
   compute_address_hash,
+  compute_drawn_keno,
   compute_multi_dice,
   compute_payout_coinflip,
   compute_payout_dice,
+  compute_payout_keno,
   compute_payout_limbo,
   compute_payout_plinko,
   compute_prediction_hash,
+  compute_prediction_hash_keno,
   compute_roll_coinflip,
   compute_roll_dice,
   compute_roll_limbo,
@@ -43,12 +46,15 @@ function guard(fn) {
 const fns = {
   amount_split:               guard(amount_split),
   compute_address_hash:       guard(compute_address_hash),
+  compute_drawn_keno:         guard(compute_drawn_keno),
   compute_multi_dice:         guard(compute_multi_dice),
   compute_payout_coinflip:    guard(compute_payout_coinflip),
   compute_payout_dice:        guard(compute_payout_dice),
+  compute_payout_keno:        guard(compute_payout_keno),
   compute_payout_limbo:       guard(compute_payout_limbo),
   compute_payout_plinko:      guard(compute_payout_plinko),
   compute_prediction_hash:    guard(compute_prediction_hash),
+  compute_prediction_hash_keno:guard(compute_prediction_hash_keno),
   compute_roll_coinflip:      guard(compute_roll_coinflip),
   compute_roll_dice:          guard(compute_roll_dice),
   compute_roll_limbo:         guard(compute_roll_limbo),

package/package.json

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