@rolly-dev/wasm-signer 0.5.1 → 0.6.1

package/dist/node/rolly_wasm_signer.js

@@ -1,5 +1,31 @@
 /* @ts-self-types="./rolly_wasm_signer.d.ts" */
 
+/**
+ * Split a u64 amount into (lo, hi) u32 pair matching the circuit representation.
+ *
+ * Returns `[amount_lo, amount_hi]` as a `Uint32Array` of length 2.
+ *
+ * ```js
+ * const [lo, hi] = amount_split(123456789n);
+ * ```
+ * @param {bigint} amount
+ * @returns {Uint32Array}
+ */
+function amount_split(amount) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.amount_split(retptr, amount);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var v1 = getArrayU32FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 4, 4);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.amount_split = amount_split;
+
 /**
  * Full Poseidon2 hash of an 8-element server seed.
  *
@@ -15,13 +41,13 @@
 function compute_server_seed_hash(server_seed) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray64ToWasm0(server_seed, wasm.__wbindgen_export2);
+        const ptr0 = passArray64ToWasm0(server_seed, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         wasm.compute_server_seed_hash(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_export3(r0, r1 * 8, 8);
+        wasm.__wbindgen_export4(r0, r1 * 8, 8);
         return v2;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -29,6 +55,36 @@ function compute_server_seed_hash(server_seed) {
 }
 exports.compute_server_seed_hash = compute_server_seed_hash;
 
+/**
+ * Compute the transaction message hash (for debugging / verification).
+ *
+ * Returns `BigUint64Array` of length 4 — the same hash the circuit computes.
+ *
+ * ```js
+ * const hash = compute_tx_msg_hash(5, userId, 0, amountLo, amountHi);
+ * ```
+ * @param {number} tx_type
+ * @param {number} user_id
+ * @param {number} currency_id
+ * @param {number} amount_lo
+ * @param {number} amount_hi
+ * @returns {BigUint64Array}
+ */
+function compute_tx_msg_hash(tx_type, user_id, currency_id, amount_lo, amount_hi) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.compute_tx_msg_hash(retptr, tx_type, user_id, currency_id, amount_lo, amount_hi);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var v1 = getArrayU64FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 8, 8);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.compute_tx_msg_hash = compute_tx_msg_hash;
+
 /**
  * Create a `bet_auth` MAC that proves the user authorized this specific bet.
  *
@@ -62,13 +118,13 @@ exports.compute_server_seed_hash = compute_server_seed_hash;
 function create_bet_auth(session_key, bet_amount, nonce) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray64ToWasm0(session_key, wasm.__wbindgen_export2);
+        const ptr0 = passArray64ToWasm0(session_key, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         wasm.create_bet_auth(retptr, ptr0, len0, bet_amount, nonce);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var v2 = getArrayU64FromWasm0(r0, r1).slice();
-        wasm.__wbindgen_export3(r0, r1 * 8, 8);
+        wasm.__wbindgen_export4(r0, r1 * 8, 8);
         return v2;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -97,13 +153,13 @@ exports.create_bet_auth = create_bet_auth;
 function derive_session_key(sig_bytes) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(sig_bytes, wasm.__wbindgen_export2);
+        const ptr0 = passArray8ToWasm0(sig_bytes, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         wasm.derive_session_key(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_export3(r0, r1 * 8, 8);
+        wasm.__wbindgen_export4(r0, r1 * 8, 8);
         return v2;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -136,7 +192,7 @@ function generate_user_seed() {
         return getStringFromWasm0(r0, r1);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export3(deferred1_0, deferred1_1, 1);
+        wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
     }
 }
 exports.generate_user_seed = generate_user_seed;
@@ -158,7 +214,7 @@ function goldilocks_fields_to_hex(fields) {
     let deferred2_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray64ToWasm0(fields, wasm.__wbindgen_export2);
+        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);
@@ -168,7 +224,7 @@ function goldilocks_fields_to_hex(fields) {
         return getStringFromWasm0(r0, r1);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
+        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
     }
 }
 exports.goldilocks_fields_to_hex = goldilocks_fields_to_hex;
@@ -216,13 +272,13 @@ exports.goldilocks_reduce = goldilocks_reduce;
 function poseidon2_hash(input) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray64ToWasm0(input, wasm.__wbindgen_export2);
+        const ptr0 = passArray64ToWasm0(input, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         wasm.poseidon2_hash(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_export3(r0, r1 * 8, 8);
+        wasm.__wbindgen_export4(r0, r1 * 8, 8);
         return v2;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -244,15 +300,15 @@ exports.poseidon2_hash = poseidon2_hash;
 function poseidon2_two_to_one(left, right) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray64ToWasm0(left, wasm.__wbindgen_export2);
+        const ptr0 = passArray64ToWasm0(left, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray64ToWasm0(right, wasm.__wbindgen_export2);
+        const ptr1 = passArray64ToWasm0(right, wasm.__wbindgen_export);
         const len1 = WASM_VECTOR_LEN;
         wasm.poseidon2_two_to_one(retptr, ptr0, len0, 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_export3(r0, r1 * 8, 8);
+        wasm.__wbindgen_export4(r0, r1 * 8, 8);
         return v3;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -260,6 +316,244 @@ function poseidon2_two_to_one(left, right) {
 }
 exports.poseidon2_two_to_one = poseidon2_two_to_one;
 
+/**
+ * Derive a Schnorr secret key from entropy bytes (e.g. MetaMask signature).
+ *
+ * Takes at least 32 bytes, uses `Scalar::decode_reduce` to map them into
+ * the ECgFp5 scalar field. Returns hex-encoded secret key (80 chars = 40 bytes).
+ *
+ * ```js
+ * const skHex = schnorr_keygen(sigBytes.slice(0, 32));
+ * ```
+ * @param {Uint8Array} entropy
+ * @returns {string}
+ */
+function schnorr_keygen(entropy) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(entropy, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.schnorr_keygen(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_export4(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.schnorr_keygen = schnorr_keygen;
+
+/**
+ * Get the w-encoding of a public key as 5 Goldilocks field elements (for circuit witness).
+ *
+ * Returns `BigUint64Array` of length 5.
+ *
+ * ```js
+ * const encode = schnorr_pk_encode(pkHex);
+ * // encode.length === 5
+ * ```
+ * @param {string} pk_hex
+ * @returns {BigUint64Array}
+ */
+function schnorr_pk_encode(pk_hex) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(pk_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.schnorr_pk_encode(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_export4(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.schnorr_pk_encode = schnorr_pk_encode;
+
+/**
+ * Compute pk_hash = Poseidon2(w_encoding[5]) from a hex-encoded public key.
+ *
+ * The w-encoding is the 40-byte (80 hex) representation returned by `schnorr_pubkey`.
+ * pk_hash is stored in the Merkle tree to bind the Schnorr key to an account.
+ *
+ * Returns `BigUint64Array` of length 4.
+ *
+ * ```js
+ * const pkHash = schnorr_pk_hash(pkHex);
+ * ```
+ * @param {string} pk_hex
+ * @returns {BigUint64Array}
+ */
+function schnorr_pk_hash(pk_hex) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(pk_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.schnorr_pk_hash(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_export4(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.schnorr_pk_hash = schnorr_pk_hash;
+
+/**
+ * Compute pk_hash as a hex string (for convenience).
+ *
+ * ```js
+ * const pkHashHex = schnorr_pk_hash_hex(pkHex);
+ * ```
+ * @param {string} pk_hex
+ * @returns {string}
+ */
+function schnorr_pk_hash_hex(pk_hex) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(pk_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.schnorr_pk_hash_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_export4(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.schnorr_pk_hash_hex = schnorr_pk_hash_hex;
+
+/**
+ * Compute the Schnorr public key from a hex-encoded secret key.
+ *
+ * Returns hex-encoded w-encoding of the ECgFp5 point (80 chars = 40 bytes).
+ *
+ * ```js
+ * const pkHex = schnorr_pubkey(skHex);
+ * ```
+ * @param {string} sk_hex
+ * @returns {string}
+ */
+function schnorr_pubkey(sk_hex) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(sk_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.schnorr_pubkey(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_export4(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.schnorr_pubkey = schnorr_pubkey;
+
+/**
+ * Sign a ChangePubKey (tx_type=9) transaction.
+ *
+ * msg_hash = Poseidon2(9, user_id, new_pk_hash[0..4])
+ *
+ * The old key signs this message to authorize key rotation.
+ *
+ * Returns a JS object: `{ pubkey: "hex", sig_r: "hex", sig_s: "hex" }`
+ *
+ * ```js
+ * const sig = schnorr_sign_cpk(oldSkHex, userId, newPkHashArray);
+ * ```
+ * @param {string} old_sk_hex
+ * @param {number} user_id
+ * @param {BigUint64Array} new_pk_hash
+ * @returns {any}
+ */
+function schnorr_sign_cpk(old_sk_hex, user_id, new_pk_hash) {
+    const ptr0 = passStringToWasm0(old_sk_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray64ToWasm0(new_pk_hash, wasm.__wbindgen_export);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.schnorr_sign_cpk(ptr0, len0, user_id, ptr1, len1);
+    return takeObject(ret);
+}
+exports.schnorr_sign_cpk = schnorr_sign_cpk;
+
+/**
+ * Sign a transaction with Schnorr (ECgFp5).
+ *
+ * msg_hash = Poseidon2(tx_type, user_id, currency_id, amount_lo, amount_hi)
+ *
+ * Returns a JS object: `{ pubkey: "hex", sig_r: "hex", sig_s: "hex" }`
+ *
+ * ```js
+ * const sig = schnorr_sign_tx(skHex, 5, userId, 0, amountBigInt);
+ * // sig.pubkey, sig.sig_r, sig.sig_s — all hex strings (80 chars each)
+ * ```
+ * @param {string} sk_hex
+ * @param {number} tx_type
+ * @param {number} user_id
+ * @param {number} currency_id
+ * @param {number} amount_lo
+ * @param {number} amount_hi
+ * @returns {any}
+ */
+function schnorr_sign_tx(sk_hex, tx_type, user_id, currency_id, amount_lo, amount_hi) {
+    const ptr0 = passStringToWasm0(sk_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.schnorr_sign_tx(ptr0, len0, tx_type, user_id, currency_id, amount_lo, amount_hi);
+    return takeObject(ret);
+}
+exports.schnorr_sign_tx = schnorr_sign_tx;
+
+/**
+ * Verify a Schnorr signature for a transaction on the backend.
+ *
+ * Checks: s·G == R + H(R‖pk‖msg)·pk
+ *
+ * Returns `true` if signature is valid, `false` otherwise.
+ *
+ * ```js
+ * const ok = schnorr_verify_tx(pubkeyHex, sigRHex, sigSHex, 5, userId, 0, amountLo, amountHi);
+ * ```
+ * @param {string} pk_hex
+ * @param {string} sig_r_hex
+ * @param {string} sig_s_hex
+ * @param {number} tx_type
+ * @param {number} user_id
+ * @param {number} currency_id
+ * @param {number} amount_lo
+ * @param {number} amount_hi
+ * @returns {boolean}
+ */
+function schnorr_verify_tx(pk_hex, sig_r_hex, sig_s_hex, tx_type, user_id, currency_id, amount_lo, amount_hi) {
+    const ptr0 = passStringToWasm0(pk_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(sig_r_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(sig_s_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.schnorr_verify_tx(ptr0, len0, ptr1, len1, ptr2, len2, tx_type, user_id, currency_id, amount_lo, amount_hi);
+    return ret !== 0;
+}
+exports.schnorr_verify_tx = schnorr_verify_tx;
+
 /**
  * Truncated seed hash — first 2 elements of `Poseidon2(server_seed)`.
  *
@@ -274,13 +568,13 @@ exports.poseidon2_two_to_one = poseidon2_two_to_one;
 function seed_hash_truncated(server_seed) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray64ToWasm0(server_seed, wasm.__wbindgen_export2);
+        const ptr0 = passArray64ToWasm0(server_seed, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         wasm.seed_hash_truncated(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_export3(r0, r1 * 8, 8);
+        wasm.__wbindgen_export4(r0, r1 * 8, 8);
         return v2;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -301,13 +595,13 @@ exports.seed_hash_truncated = seed_hash_truncated;
 function session_public_key(session_key) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray64ToWasm0(session_key, wasm.__wbindgen_export2);
+        const ptr0 = passArray64ToWasm0(session_key, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         wasm.session_public_key(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_export3(r0, r1 * 8, 8);
+        wasm.__wbindgen_export4(r0, r1 * 8, 8);
         return v2;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -334,13 +628,13 @@ exports.session_public_key = session_public_key;
 function string_to_user_seed(input) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export2, wasm.__wbindgen_export4);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         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_export3(r0, r1 * 8, 8);
+        wasm.__wbindgen_export4(r0, r1 * 8, 8);
         return v2;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -366,7 +660,7 @@ function string_to_user_seed_hex(input) {
     let deferred2_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export2, wasm.__wbindgen_export4);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
         wasm.string_to_user_seed_hex(retptr, ptr0, len0);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -376,7 +670,7 @@ function string_to_user_seed_hex(input) {
         return getStringFromWasm0(r0, r1);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
+        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
     }
 }
 exports.string_to_user_seed_hex = string_to_user_seed_hex;
@@ -384,6 +678,13 @@ exports.string_to_user_seed_hex = string_to_user_seed_hex;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg___wbindgen_debug_string_0bc8482c6e3508ae: function(arg0, arg1) {
+            const ret = debugString(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
             const ret = typeof(getObject(arg0)) === 'function';
             return ret;
@@ -427,6 +728,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).msCrypto;
             return addHeapObject(ret);
         },
+        __wbg_new_361308b2356cecd0: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
         __wbg_new_no_args_1c7c842f08d00ebb: function(arg0, arg1) {
             const ret = new Function(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
@@ -453,6 +758,10 @@ function __wbg_get_imports() {
             const ret = module.require;
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_set_6cb8631f80447a67: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
         __wbg_static_accessor_GLOBAL_12837167ad935116: function() {
             const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -510,12 +819,82 @@ function addHeapObject(obj) {
     return idx;
 }
 
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
 function dropObject(idx) {
     if (idx < 132) return;
     heap[idx] = heap_next;
     heap_next = idx;
 }
 
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU64FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getBigUint64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
@@ -547,6 +926,14 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr, len);
 }
 
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -561,7 +948,7 @@ function handleError(f, args) {
     try {
         return f.apply(this, args);
     } catch (e) {
-        wasm.__wbindgen_export(addHeapObject(e));
+        wasm.__wbindgen_export3(addHeapObject(e));
     }
 }
 

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

@@ -1,7 +1,9 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const amount_split: (a: number, b: bigint) => void;
 export const compute_server_seed_hash: (a: number, b: number, c: number) => void;
+export const compute_tx_msg_hash: (a: number, b: number, c: number, d: number, e: number, f: 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 generate_user_seed: (a: number) => void;
@@ -9,13 +11,21 @@ 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 schnorr_keygen: (a: number, b: number, c: number) => void;
+export const schnorr_pk_encode: (a: number, b: number, c: number) => void;
+export const schnorr_pk_hash: (a: number, b: number, c: number) => void;
+export const schnorr_pk_hash_hex: (a: number, b: number, c: number) => void;
+export const schnorr_pubkey: (a: number, b: number, c: number) => void;
+export const schnorr_sign_cpk: (a: number, b: number, c: number, d: number, e: number) => number;
+export const schnorr_sign_tx: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+export const schnorr_verify_tx: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => number;
 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_export: (a: number) => void;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number) => void;
 export const __wbindgen_add_to_stack_pointer: (a: number) => number;
-export const __wbindgen_export2: (a: number, b: number) => number;
-export const __wbindgen_export3: (a: number, b: number, c: number) => void;
-export const __wbindgen_export4: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export4: (a: number, b: number, c: number) => void;