@rolly-dev/wasm-signer 0.1.0

package/dist/web/README.md

@@ -0,0 +1,115 @@
+# @rolly/wasm-signer
+
+Client-side Poseidon2 hashing and bet authentication for the Rolly ZK-Rollup casino.
+
+Built with Rust → WebAssembly (via `wasm-pack`), using the same Poseidon2 hasher
+and Goldilocks field as the plonky2 proving circuit.
+
+## Build
+
+```bash
+# requires: cargo, wasm-pack
+npm run build
+# → dist/node/  (Node.js, CJS, sync init)
+# → dist/web/   (Browser, ESM, async init)
+```
+
+## Usage
+
+### Node.js (CommonJS)
+
+```javascript
+const {
+  poseidon2_hash,
+  derive_session_key,
+  session_public_key,
+  create_bet_auth,
+} = require('@rolly/wasm-signer');
+
+const hash = poseidon2_hash(BigUint64Array.from([1n, 2n, 3n]));
+// → BigUint64Array(4)
+```
+
+### Node.js (ESM)
+
+```javascript
+import {
+  poseidon2_hash,
+  derive_session_key,
+  create_bet_auth,
+} from '@rolly/wasm-signer';
+
+const hash = poseidon2_hash(BigUint64Array.from([1n, 2n, 3n]));
+```
+
+### React
+
+```jsx
+import { useRollyWasm } from '@rolly/wasm-signer/react';
+
+function BetButton({ sessionKey, amount, nonce }) {
+  const { ready, create_bet_auth } = useRollyWasm();
+
+  if (!ready) return <span>Loading...</span>;
+
+  const handleBet = () => {
+    const auth = create_bet_auth(sessionKey, BigInt(amount), BigInt(nonce));
+    // send auth to server...
+  };
+
+  return <button onClick={handleBet}>Place Bet</button>;
+}
+```
+
+### Browser (vanilla ESM)
+
+```html
+<script type="module">
+  import { init, poseidon2_hash } from '@rolly/wasm-signer';
+
+  await init();  // loads .wasm, must be called once
+  const h = poseidon2_hash(BigUint64Array.from([1n, 2n]));
+</script>
+```
+
+### Manual init (advanced)
+
+```javascript
+import init, { poseidon2_hash } from '@rolly/wasm-signer/init';
+
+// custom wasm URL or ArrayBuffer
+await init('/assets/rolly_wasm_signer_bg.wasm');
+poseidon2_hash(BigUint64Array.from([1n]));
+```
+
+## API
+
+| Function                   | Input                          | Output            | Description                                    |
+|----------------------------|--------------------------------|-------------------|------------------------------------------------|
+| `poseidon2_hash`           | `BigUint64Array`               | `BigUint64Array(4)` | Hash N field elements                        |
+| `poseidon2_two_to_one`     | `BigUint64Array(4)` × 2        | `BigUint64Array(4)` | Merkle hash: H(left‖right)                   |
+| `derive_session_key`       | `Uint8Array(32)`               | `BigUint64Array(4)` | MetaMask sig → session key                   |
+| `session_public_key`       | `BigUint64Array(4)`            | `BigUint64Array(4)` | session_pk = H(session_key)                  |
+| `create_bet_auth`          | `(BigUint64Array(4), bigint, bigint)` | `BigUint64Array(4)` | MAC = H(sk‖amount_lo‖amount_hi‖nonce)  |
+| `compute_server_seed_hash` | `BigUint64Array(8)`            | `BigUint64Array(4)` | Full hash of server seed                     |
+| `seed_hash_truncated`      | `BigUint64Array(8)`            | `BigUint64Array(2)` | First 2 elements (circuit leaf format)       |
+| `goldilocks_modulus`       | —                              | `bigint`          | Returns p = 2^64 - 2^32 + 1                   |
+| `goldilocks_reduce`        | `bigint`                       | `bigint`          | Reduce mod p                                   |
+
+## Bundler notes
+
+**Vite** — add to `optimizeDeps.exclude`:
+```js
+optimizeDeps: { exclude: ['@rolly/wasm-signer'] }
+```
+
+**Webpack 5** — enable WASM experiments:
+```js
+module.exports = { experiments: { asyncWebAssembly: true } };
+```
+
+**Next.js** — conditional exports auto-resolve: Node.js entry on server, browser entry on client.
+
+## License
+
+MIT

package/dist/web/rolly_wasm_signer.d.ts

@@ -0,0 +1,160 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Full Poseidon2 hash of an 8-element server seed.
+ *
+ * Returns all 4 hash elements.  Note: the circuit stores only the
+ * **first 2 elements** as the leaf commitment (see `seed_hash_truncated`).
+ * This full variant is useful for client-side verification where all
+ * 4 elements may be needed.
+ *
+ * `server_seed` must be exactly 8 elements.
+ */
+export function compute_server_seed_hash(server_seed: BigUint64Array): BigUint64Array;
+
+/**
+ * Create a `bet_auth` MAC that proves the user authorized this specific bet.
+ *
+ * ```text
+ * bet_auth = Poseidon2(
+ *     session_key[0..4],   // 4 field elements (private)
+ *     amount_lo,           // lower  32 bits of bet_amount
+ *     amount_hi,           // upper  32 bits of bet_amount
+ *     nonce,               // monotonic counter, prevents replay
+ * )
+ * ```
+ *
+ * The circuit verifies two things:
+ *   1. `session_pk == Poseidon2(session_key)` — knowledge of key
+ *   2. `bet_auth  == Poseidon2(session_key ‖ amount_lo ‖ amount_hi ‖ nonce)`
+ *
+ * The lo/hi split matches `src/circuit/main_circuit.rs` witness assignment:
+ *   `amount as u32` / `(amount >> 32) as u32`, both via `from_canonical_u32`.
+ *
+ * **Parameters**
+ * - `session_key` : 4 × u64  (private, from `derive_session_key`)
+ * - `bet_amount`  : u64      (in smallest currency units)
+ * - `nonce`       : u64      (incrementing per-session counter)
+ *
+ * **Returns**: 4 × u64 (`bet_auth` hash)
+ */
+export function create_bet_auth(session_key: BigUint64Array, bet_amount: bigint, nonce: bigint): BigUint64Array;
+
+/**
+ * Derive a session key from 32 bytes of entropy (e.g. MetaMask signature).
+ *
+ * **Algorithm**: split 32 bytes into 4 × 8 bytes, interpret each chunk as
+ * little-endian u64, reduce mod p, then hash:
+ *   `session_key = Poseidon2(reduced_chunks)`
+ *
+ * The reduction via `from_noncanonical_u64` is necessary because raw
+ * signature bytes can produce values >= p.
+ *
+ * ```js
+ * const sig = ethers.getBytes(metaMaskSignature).slice(0, 32);
+ * const sk  = derive_session_key(new Uint8Array(sig));
+ * // sk.length === 4
+ * ```
+ */
+export function derive_session_key(sig_bytes: Uint8Array): BigUint64Array;
+
+/**
+ * Returns the Goldilocks prime: p = 2^64 - 2^32 + 1.
+ */
+export function goldilocks_modulus(): bigint;
+
+/**
+ * Reduce an arbitrary u64 to its canonical representative mod p.
+ *
+ * Values already < p are returned unchanged.  Values >= p are reduced.
+ * This uses `from_noncanonical_u64` internally (no panic on large values).
+ */
+export function goldilocks_reduce(value: bigint): bigint;
+
+/**
+ * Poseidon2 hash of an arbitrary number of Goldilocks field elements.
+ *
+ * Mirrors `builder.hash_n_to_hash_no_pad::<Poseidon2Hash>(...)` inside
+ * the circuit and `Poseidon2Hash::hash_no_pad` in `src/block_builder`.
+ *
+ * **Input** : `BigUint64Array` — each element must be < `GOLDILOCKS_P`.
+ * **Output**: `BigUint64Array` of length 4 (one `HashOut`).
+ *
+ * ```js
+ * const h = poseidon2_hash(BigUint64Array.from([1n, 2n, 3n]));
+ * // h.length === 4
+ * ```
+ */
+export function poseidon2_hash(input: BigUint64Array): BigUint64Array;
+
+/**
+ * Merkle-tree hash: Poseidon2(left[4] ‖ right[4]).
+ *
+ * Identical to `poseidon_hash(left, right)` in `src/merkletree/hash.rs`.
+ * Input ordering is critical — `left` concatenated before `right`.
+ *
+ * Both arrays **must** have exactly 4 elements (one `HashOut` each).
+ */
+export function poseidon2_two_to_one(left: BigUint64Array, right: BigUint64Array): BigUint64Array;
+
+/**
+ * Truncated seed hash — first 2 elements of `Poseidon2(server_seed)`.
+ *
+ * This is the exact format stored in the Merkle-tree leaf and verified
+ * by the circuit.  Matches `seed_hash_truncated` in
+ * `src/block_builder/builder.rs` and `src/circuit/main_circuit.rs`.
+ *
+ * Returns `BigUint64Array` of length 2: `[h[0], h[1]]`.
+ */
+export function seed_hash_truncated(server_seed: BigUint64Array): BigUint64Array;
+
+/**
+ * Compute the public key for a session: `session_pk = Poseidon2(session_key)`.
+ *
+ * The public key is stored in the user-asset Merkle leaf and verified
+ * inside the circuit (the prover must know the preimage `session_key`).
+ *
+ * `session_key` must be exactly 4 elements (output of `derive_session_key`).
+ */
+export function session_public_key(session_key: BigUint64Array): BigUint64Array;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    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_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 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;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/dist/web/rolly_wasm_signer.js

@@ -0,0 +1,415 @@
+/* @ts-self-types="./rolly_wasm_signer.d.ts" */
+
+/**
+ * Full Poseidon2 hash of an 8-element server seed.
+ *
+ * Returns all 4 hash elements.  Note: the circuit stores only the
+ * **first 2 elements** as the leaf commitment (see `seed_hash_truncated`).
+ * This full variant is useful for client-side verification where all
+ * 4 elements may be needed.
+ *
+ * `server_seed` must be exactly 8 elements.
+ * @param {BigUint64Array} server_seed
+ * @returns {BigUint64Array}
+ */
+export function compute_server_seed_hash(server_seed) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        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_export2(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Create a `bet_auth` MAC that proves the user authorized this specific bet.
+ *
+ * ```text
+ * bet_auth = Poseidon2(
+ *     session_key[0..4],   // 4 field elements (private)
+ *     amount_lo,           // lower  32 bits of bet_amount
+ *     amount_hi,           // upper  32 bits of bet_amount
+ *     nonce,               // monotonic counter, prevents replay
+ * )
+ * ```
+ *
+ * The circuit verifies two things:
+ *   1. `session_pk == Poseidon2(session_key)` — knowledge of key
+ *   2. `bet_auth  == Poseidon2(session_key ‖ amount_lo ‖ amount_hi ‖ nonce)`
+ *
+ * The lo/hi split matches `src/circuit/main_circuit.rs` witness assignment:
+ *   `amount as u32` / `(amount >> 32) as u32`, both via `from_canonical_u32`.
+ *
+ * **Parameters**
+ * - `session_key` : 4 × u64  (private, from `derive_session_key`)
+ * - `bet_amount`  : u64      (in smallest currency units)
+ * - `nonce`       : u64      (incrementing per-session counter)
+ *
+ * **Returns**: 4 × u64 (`bet_auth` hash)
+ * @param {BigUint64Array} session_key
+ * @param {bigint} bet_amount
+ * @param {bigint} nonce
+ * @returns {BigUint64Array}
+ */
+export 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_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_export2(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Derive a session key from 32 bytes of entropy (e.g. MetaMask signature).
+ *
+ * **Algorithm**: split 32 bytes into 4 × 8 bytes, interpret each chunk as
+ * little-endian u64, reduce mod p, then hash:
+ *   `session_key = Poseidon2(reduced_chunks)`
+ *
+ * The reduction via `from_noncanonical_u64` is necessary because raw
+ * signature bytes can produce values >= p.
+ *
+ * ```js
+ * const sig = ethers.getBytes(metaMaskSignature).slice(0, 32);
+ * const sk  = derive_session_key(new Uint8Array(sig));
+ * // sk.length === 4
+ * ```
+ * @param {Uint8Array} sig_bytes
+ * @returns {BigUint64Array}
+ */
+export function derive_session_key(sig_bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        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_export2(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Returns the Goldilocks prime: p = 2^64 - 2^32 + 1.
+ * @returns {bigint}
+ */
+export function goldilocks_modulus() {
+    const ret = wasm.goldilocks_modulus();
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * Reduce an arbitrary u64 to its canonical representative mod p.
+ *
+ * Values already < p are returned unchanged.  Values >= p are reduced.
+ * This uses `from_noncanonical_u64` internally (no panic on large values).
+ * @param {bigint} value
+ * @returns {bigint}
+ */
+export function goldilocks_reduce(value) {
+    const ret = wasm.goldilocks_reduce(value);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * Poseidon2 hash of an arbitrary number of Goldilocks field elements.
+ *
+ * Mirrors `builder.hash_n_to_hash_no_pad::<Poseidon2Hash>(...)` inside
+ * the circuit and `Poseidon2Hash::hash_no_pad` in `src/block_builder`.
+ *
+ * **Input** : `BigUint64Array` — each element must be < `GOLDILOCKS_P`.
+ * **Output**: `BigUint64Array` of length 4 (one `HashOut`).
+ *
+ * ```js
+ * const h = poseidon2_hash(BigUint64Array.from([1n, 2n, 3n]));
+ * // h.length === 4
+ * ```
+ * @param {BigUint64Array} input
+ * @returns {BigUint64Array}
+ */
+export function poseidon2_hash(input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        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_export2(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Merkle-tree hash: Poseidon2(left[4] ‖ right[4]).
+ *
+ * Identical to `poseidon_hash(left, right)` in `src/merkletree/hash.rs`.
+ * Input ordering is critical — `left` concatenated before `right`.
+ *
+ * Both arrays **must** have exactly 4 elements (one `HashOut` each).
+ * @param {BigUint64Array} left
+ * @param {BigUint64Array} right
+ * @returns {BigUint64Array}
+ */
+export function poseidon2_two_to_one(left, right) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray64ToWasm0(left, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        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_export2(r0, r1 * 8, 8);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Truncated seed hash — first 2 elements of `Poseidon2(server_seed)`.
+ *
+ * This is the exact format stored in the Merkle-tree leaf and verified
+ * by the circuit.  Matches `seed_hash_truncated` in
+ * `src/block_builder/builder.rs` and `src/circuit/main_circuit.rs`.
+ *
+ * Returns `BigUint64Array` of length 2: `[h[0], h[1]]`.
+ * @param {BigUint64Array} server_seed
+ * @returns {BigUint64Array}
+ */
+export function seed_hash_truncated(server_seed) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        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_export2(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Compute the public key for a session: `session_pk = Poseidon2(session_key)`.
+ *
+ * The public key is stored in the user-asset Merkle leaf and verified
+ * inside the circuit (the prover must know the preimage `session_key`).
+ *
+ * `session_key` must be exactly 4 elements (output of `derive_session_key`).
+ * @param {BigUint64Array} session_key
+ * @returns {BigUint64Array}
+ */
+export function session_public_key(session_key) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        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_export2(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+    };
+    return {
+        __proto__: null,
+        "./rolly_wasm_signer_bg.js": import0,
+    };
+}
+
+function getArrayU64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getBigUint64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+let cachedBigUint64ArrayMemory0 = null;
+function getBigUint64ArrayMemory0() {
+    if (cachedBigUint64ArrayMemory0 === null || cachedBigUint64ArrayMemory0.byteLength === 0) {
+        cachedBigUint64ArrayMemory0 = new BigUint64Array(wasm.memory.buffer);
+    }
+    return cachedBigUint64ArrayMemory0;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passArray64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getBigUint64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedBigUint64ArrayMemory0 = null;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('rolly_wasm_signer_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };