ox 1.1.0 → 1.2.0

package/src/wasm/internal/instantiate.ts

@@ -48,18 +48,23 @@ function decode(base64: string): Uint8Array {
 }
 
 /**
- * Instantiates a base64-encoded WASM module.
+ * Compiles a base64-encoded WASM module without instantiating it.
  *
- * Always asynchronous: browsers refuse to compile modules larger than a few
- * kilobytes synchronously on the main thread, so there is no synchronous path to
- * fall back to. Callers await this once and then call the module synchronously.
+ * @internal
+ */
+export async function compile(base64: string): Promise<WebAssembly.Module> {
+  return WebAssembly.compile(decode(base64))
+}
+
+/**
+ * Instantiates a compiled WASM module.
  *
  * @internal
  */
-export async function instantiate<exports extends Record<string, unknown>>(
-  base64: string,
-): Promise<Module<exports>> {
-  const { instance } = await WebAssembly.instantiate(decode(base64), {})
+export async function instantiateModule<
+  exports extends Record<string, unknown>,
+>(compiled: WebAssembly.Module): Promise<Module<exports>> {
+  const instance = await WebAssembly.instantiate(compiled, {})
   const exports = instance.exports as {
     heap_base(): number
     memory: WebAssembly.Memory
@@ -94,6 +99,21 @@ export async function instantiate<exports extends Record<string, unknown>>(
   }
 }
 
+/**
+ * Instantiates a base64-encoded WASM module.
+ *
+ * Always asynchronous: browsers refuse to compile modules larger than a few
+ * kilobytes synchronously on the main thread, so there is no synchronous path to
+ * fall back to. Callers await this once and then call the module synchronously.
+ *
+ * @internal
+ */
+export async function instantiate<exports extends Record<string, unknown>>(
+  base64: string,
+): Promise<Module<exports>> {
+  return instantiateModule(await compile(base64))
+}
+
 /**
  * Memoizes a loader so concurrent callers compile the module once.
  *
@@ -128,7 +148,7 @@ export class MemoryError extends Errors.BaseError<Error> {
       cause,
       metaMessages: [
         `Required: ${bytes} bytes`,
-        'The input may be too large for this runtime. Reset the engine slot with `Engine.reset` to fall back to the default implementation.',
+        'The input or requested workspace may be too large for this runtime. Reset the engine slot with `Engine.reset` to fall back to the default implementation.',
       ],
     })
   }

package/src/wasm/internal/keystore.ts

@@ -0,0 +1,19 @@
+import type * as Engine from '../../core/Engine.js'
+import * as hashes from './hashes.js'
+import * as pbkdf2 from './pbkdf2.js'
+
+/** Compiles the aggregate engine's synchronous PBKDF2 implementation. */
+export async function engine(): Promise<engine.ReturnType> {
+  const module = await hashes.load()
+  return {
+    pbkdf2Sha256: (password, salt, options) =>
+      pbkdf2.pbkdf2Sha256(module, password, salt, options),
+  }
+}
+
+export declare namespace engine {
+  /** The aggregate WASM engine's `Keystore` primitives. */
+  type ReturnType = {
+    pbkdf2Sha256: NonNullable<Engine.Keystore['pbkdf2Sha256']>
+  }
+}

package/src/wasm/internal/kzg.ts

@@ -0,0 +1,50 @@
+import {
+  compile,
+  instantiateModule,
+  memoize,
+  type Module,
+} from './instantiate.js'
+import { wasmBase64 } from './kzg.wasm.js'
+
+/** Exports supplied by the dedicated c-kzg artifact. @internal */
+export type Exports = {
+  alloc(size: number): number
+  dealloc(ptr: number): void
+  kzg_blob_to_kzg_commitment(out: number, blob: number): number
+  kzg_compute_cells(cells: number, blob: number): number
+  kzg_compute_cells_and_kzg_proofs(
+    cells: number,
+    proofs: number,
+    blob: number,
+  ): number
+  kzg_dispose(): void
+  kzg_initialize(
+    g1Monomial: number,
+    g1Lagrange: number,
+    g2Monomial: number,
+    precompute: number,
+  ): number
+  kzg_recover_cells_and_kzg_proofs(
+    recoveredCells: number,
+    recoveredProofs: number,
+    cellIndices: number,
+    cells: number,
+    count: number,
+  ): number
+  kzg_verify_cell_kzg_proof_batch(
+    verified: number,
+    commitments: number,
+    cellIndices: number,
+    cells: number,
+    proofs: number,
+    count: number,
+  ): number
+  zero(ptr: number, length: number): void
+}
+
+const load = memoize(() => compile(wasmBase64))
+
+/** Instantiates an independently owned c-kzg module. @internal */
+export async function instantiate(): Promise<Module<Exports>> {
+  return instantiateModule(await load())
+}