@rolly-dev/wasm-signer 0.1.2 → 0.3.0

package/dist/node/rolly_wasm_signer.d.ts

@@ -59,6 +59,18 @@ export function create_bet_auth(session_key: BigUint64Array, bet_amount: bigint,
  */
 export function derive_session_key(sig_bytes: Uint8Array): BigUint64Array;
 
+/**
+ * Convert any Goldilocks field elements to a hex string.
+ *
+ * Each u64 is encoded as 8 little-endian bytes → 16 hex chars.
+ * For 4 elements: 64 hex chars (32 bytes).
+ *
+ * ```js
+ * const hex = goldilocks_fields_to_hex(BigUint64Array.from([1n, 2n, 3n, 4n]));
+ * ```
+ */
+export function goldilocks_fields_to_hex(fields: BigUint64Array): string;
+
 /**
  * Returns the Goldilocks prime: p = 2^64 - 2^32 + 1.
  */
@@ -118,3 +130,32 @@ export function seed_hash_truncated(server_seed: BigUint64Array): BigUint64Array
  * `session_key` must be exactly 4 elements (output of `derive_session_key`).
  */
 export function session_public_key(session_key: BigUint64Array): BigUint64Array;
+
+/**
+ * Convert a user seed string to 4 Goldilocks field elements.
+ *
+ * `SHA-256(str)` → split into 4 × 8 LE bytes → reduce each mod p.
+ *
+ * This matches the backend's `stringToUserSeed` and produces the exact
+ * field elements used in the provably-fair random computation:
+ *   `random = Poseidon2(server_seed ‖ user_seed)`
+ *
+ * ```js
+ * const fields = string_to_user_seed("my-seed-123");
+ * // fields.length === 4, each < GOLDILOCKS_P
+ * ```
+ */
+export function string_to_user_seed(input: string): BigUint64Array;
+
+/**
+ * Convert a user seed string directly to a hex representation.
+ *
+ * Equivalent to `goldiLocksFieldsToHex(stringToUserSeed(str))`.
+ * Returns a 64-character lowercase hex string (32 bytes).
+ *
+ * ```js
+ * const hex = string_to_user_seed_hex("my-seed-123");
+ * // hex === "a1b2c3..." (64 chars)
+ * ```
+ */
+export function string_to_user_seed_hex(input: string): string;

package/dist/node/rolly_wasm_signer.js

@@ -111,6 +111,38 @@ function derive_session_key(sig_bytes) {
 }
 exports.derive_session_key = derive_session_key;
 
+/**
+ * Convert any Goldilocks field elements to a hex string.
+ *
+ * Each u64 is encoded as 8 little-endian bytes → 16 hex chars.
+ * For 4 elements: 64 hex chars (32 bytes).
+ *
+ * ```js
+ * const hex = goldilocks_fields_to_hex(BigUint64Array.from([1n, 2n, 3n, 4n]));
+ * ```
+ * @param {BigUint64Array} fields
+ * @returns {string}
+ */
+function goldilocks_fields_to_hex(fields) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray64ToWasm0(fields, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.goldilocks_fields_to_hex(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.goldilocks_fields_to_hex = goldilocks_fields_to_hex;
+
 /**
  * Returns the Goldilocks prime: p = 2^64 - 2^32 + 1.
  * @returns {bigint}
@@ -253,6 +285,72 @@ function session_public_key(session_key) {
 }
 exports.session_public_key = session_public_key;
 
+/**
+ * Convert a user seed string to 4 Goldilocks field elements.
+ *
+ * `SHA-256(str)` → split into 4 × 8 LE bytes → reduce each mod p.
+ *
+ * This matches the backend's `stringToUserSeed` and produces the exact
+ * field elements used in the provably-fair random computation:
+ *   `random = Poseidon2(server_seed ‖ user_seed)`
+ *
+ * ```js
+ * const fields = string_to_user_seed("my-seed-123");
+ * // fields.length === 4, each < GOLDILOCKS_P
+ * ```
+ * @param {string} input
+ * @returns {BigUint64Array}
+ */
+function string_to_user_seed(input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.string_to_user_seed(retptr, 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);
+    }
+}
+exports.string_to_user_seed = string_to_user_seed;
+
+/**
+ * Convert a user seed string directly to a hex representation.
+ *
+ * Equivalent to `goldiLocksFieldsToHex(stringToUserSeed(str))`.
+ * Returns a 64-character lowercase hex string (32 bytes).
+ *
+ * ```js
+ * const hex = string_to_user_seed_hex("my-seed-123");
+ * // hex === "a1b2c3..." (64 chars)
+ * ```
+ * @param {string} input
+ * @returns {string}
+ */
+function string_to_user_seed_hex(input) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.string_to_user_seed_hex(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.string_to_user_seed_hex = string_to_user_seed_hex;
+
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -314,12 +412,62 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 cachedTextDecoder.decode();
 function decodeText(ptr, len) {
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
 let WASM_VECTOR_LEN = 0;
 
 const wasmPath = `${__dirname}/rolly_wasm_signer_bg.wasm`;

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

@@ -4,12 +4,16 @@ export const memory: WebAssembly.Memory;
 export const compute_server_seed_hash: (a: number, b: number, c: number) => void;
 export const create_bet_auth: (a: number, b: number, c: number, d: bigint, e: bigint) => void;
 export const derive_session_key: (a: number, b: number, c: number) => void;
+export const goldilocks_fields_to_hex: (a: number, b: number, c: number) => void;
 export const goldilocks_reduce: (a: bigint) => bigint;
 export const poseidon2_hash: (a: number, b: number, c: number) => void;
 export const poseidon2_two_to_one: (a: number, b: number, c: number, d: number, e: number) => void;
 export const seed_hash_truncated: (a: number, b: number, c: number) => void;
 export const session_public_key: (a: number, b: number, c: number) => 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 goldilocks_modulus: () => bigint;
 export const __wbindgen_add_to_stack_pointer: (a: number) => number;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number) => void;
+export const __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;

package/dist/web/rolly_wasm_signer.d.ts

@@ -59,6 +59,18 @@ export function create_bet_auth(session_key: BigUint64Array, bet_amount: bigint,
  */
 export function derive_session_key(sig_bytes: Uint8Array): BigUint64Array;
 
+/**
+ * Convert any Goldilocks field elements to a hex string.
+ *
+ * Each u64 is encoded as 8 little-endian bytes → 16 hex chars.
+ * For 4 elements: 64 hex chars (32 bytes).
+ *
+ * ```js
+ * const hex = goldilocks_fields_to_hex(BigUint64Array.from([1n, 2n, 3n, 4n]));
+ * ```
+ */
+export function goldilocks_fields_to_hex(fields: BigUint64Array): string;
+
 /**
  * Returns the Goldilocks prime: p = 2^64 - 2^32 + 1.
  */
@@ -119,6 +131,35 @@ export function seed_hash_truncated(server_seed: BigUint64Array): BigUint64Array
  */
 export function session_public_key(session_key: BigUint64Array): BigUint64Array;
 
+/**
+ * Convert a user seed string to 4 Goldilocks field elements.
+ *
+ * `SHA-256(str)` → split into 4 × 8 LE bytes → reduce each mod p.
+ *
+ * This matches the backend's `stringToUserSeed` and produces the exact
+ * field elements used in the provably-fair random computation:
+ *   `random = Poseidon2(server_seed ‖ user_seed)`
+ *
+ * ```js
+ * const fields = string_to_user_seed("my-seed-123");
+ * // fields.length === 4, each < GOLDILOCKS_P
+ * ```
+ */
+export function string_to_user_seed(input: string): BigUint64Array;
+
+/**
+ * Convert a user seed string directly to a hex representation.
+ *
+ * Equivalent to `goldiLocksFieldsToHex(stringToUserSeed(str))`.
+ * Returns a 64-character lowercase hex string (32 bytes).
+ *
+ * ```js
+ * const hex = string_to_user_seed_hex("my-seed-123");
+ * // hex === "a1b2c3..." (64 chars)
+ * ```
+ */
+export function string_to_user_seed_hex(input: string): string;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
@@ -126,15 +167,19 @@ export interface InitOutput {
     readonly compute_server_seed_hash: (a: number, b: number, c: number) => void;
     readonly create_bet_auth: (a: number, b: number, c: number, d: bigint, e: bigint) => void;
     readonly derive_session_key: (a: number, b: number, c: number) => void;
+    readonly goldilocks_fields_to_hex: (a: number, b: number, c: number) => void;
     readonly goldilocks_reduce: (a: bigint) => bigint;
     readonly poseidon2_hash: (a: number, b: number, c: number) => void;
     readonly poseidon2_two_to_one: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly seed_hash_truncated: (a: number, b: number, c: number) => void;
     readonly session_public_key: (a: number, b: number, c: number) => 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 goldilocks_modulus: () => bigint;
     readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
 }
 
 export type SyncInitInput = BufferSource | WebAssembly.Module;

package/dist/web/rolly_wasm_signer.js

@@ -108,6 +108,37 @@ export function derive_session_key(sig_bytes) {
     }
 }
 
+/**
+ * Convert any Goldilocks field elements to a hex string.
+ *
+ * Each u64 is encoded as 8 little-endian bytes → 16 hex chars.
+ * For 4 elements: 64 hex chars (32 bytes).
+ *
+ * ```js
+ * const hex = goldilocks_fields_to_hex(BigUint64Array.from([1n, 2n, 3n, 4n]));
+ * ```
+ * @param {BigUint64Array} fields
+ * @returns {string}
+ */
+export function goldilocks_fields_to_hex(fields) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray64ToWasm0(fields, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.goldilocks_fields_to_hex(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Returns the Goldilocks prime: p = 2^64 - 2^32 + 1.
  * @returns {bigint}
@@ -244,6 +275,70 @@ export function session_public_key(session_key) {
     }
 }
 
+/**
+ * Convert a user seed string to 4 Goldilocks field elements.
+ *
+ * `SHA-256(str)` → split into 4 × 8 LE bytes → reduce each mod p.
+ *
+ * This matches the backend's `stringToUserSeed` and produces the exact
+ * field elements used in the provably-fair random computation:
+ *   `random = Poseidon2(server_seed ‖ user_seed)`
+ *
+ * ```js
+ * const fields = string_to_user_seed("my-seed-123");
+ * // fields.length === 4, each < GOLDILOCKS_P
+ * ```
+ * @param {string} input
+ * @returns {BigUint64Array}
+ */
+export function string_to_user_seed(input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.string_to_user_seed(retptr, 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);
+    }
+}
+
+/**
+ * Convert a user seed string directly to a hex representation.
+ *
+ * Equivalent to `goldiLocksFieldsToHex(stringToUserSeed(str))`.
+ * Returns a 64-character lowercase hex string (32 bytes).
+ *
+ * ```js
+ * const hex = string_to_user_seed_hex("my-seed-123");
+ * // hex === "a1b2c3..." (64 chars)
+ * ```
+ * @param {string} input
+ * @returns {string}
+ */
+export function string_to_user_seed_hex(input) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.string_to_user_seed_hex(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
+    }
+}
+
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -305,6 +400,43 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 cachedTextDecoder.decode();
 const MAX_SAFARI_DECODE_BYTES = 2146435072;
@@ -319,6 +451,19 @@ function decodeText(ptr, len) {
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
 let WASM_VECTOR_LEN = 0;
 
 let wasmModule, wasm;

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

@@ -4,12 +4,16 @@ export const memory: WebAssembly.Memory;
 export const compute_server_seed_hash: (a: number, b: number, c: number) => void;
 export const create_bet_auth: (a: number, b: number, c: number, d: bigint, e: bigint) => void;
 export const derive_session_key: (a: number, b: number, c: number) => void;
+export const goldilocks_fields_to_hex: (a: number, b: number, c: number) => void;
 export const goldilocks_reduce: (a: bigint) => bigint;
 export const poseidon2_hash: (a: number, b: number, c: number) => void;
 export const poseidon2_two_to_one: (a: number, b: number, c: number, d: number, e: number) => void;
 export const seed_hash_truncated: (a: number, b: number, c: number) => void;
 export const session_public_key: (a: number, b: number, c: number) => 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 goldilocks_modulus: () => bigint;
 export const __wbindgen_add_to_stack_pointer: (a: number) => number;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number) => void;
+export const __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;

package/js/browser.d.mts

@@ -6,6 +6,9 @@ export {
   create_bet_auth,
   compute_server_seed_hash,
   seed_hash_truncated,
+  string_to_user_seed,
+  string_to_user_seed_hex,
+  goldilocks_fields_to_hex,
   goldilocks_modulus,
   goldilocks_reduce,
 } from '../dist/web/rolly_wasm_signer.js';

package/js/browser.mjs

@@ -8,6 +8,9 @@ export {
   create_bet_auth,
   compute_server_seed_hash,
   seed_hash_truncated,
+  string_to_user_seed,
+  string_to_user_seed_hex,
+  goldilocks_fields_to_hex,
   goldilocks_modulus,
   goldilocks_reduce,
 } from '../dist/web/rolly_wasm_signer.js';

package/js/index.d.ts

@@ -6,6 +6,9 @@ export {
   create_bet_auth,
   compute_server_seed_hash,
   seed_hash_truncated,
+  string_to_user_seed,
+  string_to_user_seed_hex,
+  goldilocks_fields_to_hex,
   goldilocks_modulus,
   goldilocks_reduce,
 } from '../dist/node/rolly_wasm_signer.js';

package/js/node.cjs

@@ -10,6 +10,9 @@ module.exports = {
   create_bet_auth:          wasm.create_bet_auth,
   compute_server_seed_hash: wasm.compute_server_seed_hash,
   seed_hash_truncated:      wasm.seed_hash_truncated,
+  string_to_user_seed:      wasm.string_to_user_seed,
+  string_to_user_seed_hex:  wasm.string_to_user_seed_hex,
+  goldilocks_fields_to_hex: wasm.goldilocks_fields_to_hex,
   goldilocks_modulus:       wasm.goldilocks_modulus,
   goldilocks_reduce:        wasm.goldilocks_reduce,
 };

package/js/node.mjs

@@ -11,6 +11,9 @@ export const {
   create_bet_auth,
   compute_server_seed_hash,
   seed_hash_truncated,
+  string_to_user_seed,
+  string_to_user_seed_hex,
+  goldilocks_fields_to_hex,
   goldilocks_modulus,
   goldilocks_reduce,
 } = wasm;

package/js/react.d.mts

@@ -8,6 +8,9 @@ export interface RollyWasmResult {
   create_bet_auth:          ((session_key: BigUint64Array, bet_amount: bigint, nonce: bigint) => BigUint64Array) | null;
   compute_server_seed_hash: ((server_seed: BigUint64Array) => BigUint64Array) | null;
   seed_hash_truncated:      ((server_seed: BigUint64Array) => BigUint64Array) | null;
+  string_to_user_seed:      ((input: string) => BigUint64Array) | null;
+  string_to_user_seed_hex:  ((input: string) => string) | null;
+  goldilocks_fields_to_hex: ((fields: BigUint64Array) => string) | null;
   goldilocks_modulus:       (() => bigint) | null;
   goldilocks_reduce:        ((value: bigint) => bigint) | null;
 }

package/js/react.mjs

@@ -7,6 +7,9 @@ import init, {
   create_bet_auth,
   compute_server_seed_hash,
   seed_hash_truncated,
+  string_to_user_seed,
+  string_to_user_seed_hex,
+  goldilocks_fields_to_hex,
   goldilocks_modulus,
   goldilocks_reduce,
 } from '../dist/web/rolly_wasm_signer.js';
@@ -51,6 +54,9 @@ export function useRollyWasm() {
     create_bet_auth:          ready ? create_bet_auth : null,
     compute_server_seed_hash: ready ? compute_server_seed_hash : null,
     seed_hash_truncated:      ready ? seed_hash_truncated : null,
+    string_to_user_seed:      ready ? string_to_user_seed : null,
+    string_to_user_seed_hex:  ready ? string_to_user_seed_hex : null,
+    goldilocks_fields_to_hex: ready ? goldilocks_fields_to_hex : null,
     goldilocks_modulus:       ready ? goldilocks_modulus : null,
     goldilocks_reduce:        ready ? goldilocks_reduce : null,
   };

package/package.json

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