ox 1.1.2 → 1.3.0

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.1.2'
+export const version = '1.3.0'

package/src/wasm/Engine.ts

@@ -2,7 +2,7 @@ import * as CoreEngine from '../core/Engine.js'
 import type * as Errors from '../core/Errors.js'
 import * as Ed25519 from './Ed25519.js'
 import * as Hash from './Hash.js'
-import * as Keystore from './Keystore.js'
+import * as keystore from './internal/keystore.js'
 import * as Mnemonic from './Mnemonic.js'
 import * as X25519 from './X25519.js'
 import type * as internal from './internal/instantiate.js'
@@ -24,6 +24,7 @@ export type {
   Eddsa,
   Engine,
   Hash,
+  HashState,
   Keystore,
   Mnemonic,
 } from '../core/Engine.js'
@@ -54,7 +55,7 @@ export async function install(): Promise<install.ReturnType> {
   return CoreEngine.install({
     Ed25519: Ed25519.engine(),
     Hash: Hash.engine(),
-    Keystore: Keystore.engine(),
+    Keystore: keystore.engine(),
     Mnemonic: Mnemonic.engine(),
     X25519: X25519.engine(),
   })
@@ -91,17 +92,17 @@ export declare namespace install {
  * @returns An engine, ready to install.
  */
 export async function engine(): Promise<engine.ReturnType> {
-  const [ed25519, hash, keystore, mnemonic, x25519] = await Promise.all([
+  const [ed25519, hash, keystoreEngine, mnemonic, x25519] = await Promise.all([
     Ed25519.engine(),
     Hash.engine(),
-    Keystore.engine(),
+    keystore.engine(),
     Mnemonic.engine(),
     X25519.engine(),
   ])
   return {
     Ed25519: ed25519,
     Hash: hash,
-    Keystore: keystore,
+    Keystore: keystoreEngine,
     Mnemonic: mnemonic,
     X25519: x25519,
   }
@@ -112,7 +113,9 @@ export declare namespace engine {
   type ReturnType = {
     Ed25519: Ed25519.engine.ReturnType
     Hash: Hash.engine.ReturnType
-    Keystore: Keystore.engine.ReturnType
+    Keystore: {
+      pbkdf2Sha256: NonNullable<CoreEngine.Keystore['pbkdf2Sha256']>
+    }
     Mnemonic: Mnemonic.engine.ReturnType
     X25519: X25519.engine.ReturnType
   }

package/src/wasm/Hash.ts

@@ -65,6 +65,11 @@ export async function engine(): Promise<engine.ReturnType> {
 
     return {
       blake3: (input) => blake3.hash(blake3Module, input),
+      createBlake3: () => blake3.create(blake3Module),
+      createHmacSha256: (key) => hash.createHmacSha256(module, key),
+      createKeccak256: () => hashes.create(module, 'keccak256'),
+      createRipemd160: () => hashes.create(module, 'ripemd160'),
+      createSha256: () => hashes.create(module, 'sha256'),
       hmacSha256: (key, message) => hash.hmacSha256(module, key, message),
       keccak256: (input) => call('keccak256', input),
       ripemd160: (input) => call('ripemd160', input),
@@ -78,6 +83,11 @@ export declare namespace engine {
   type ReturnType = {
     [key in
       | 'blake3'
+      | 'createBlake3'
+      | 'createHmacSha256'
+      | 'createKeccak256'
+      | 'createRipemd160'
+      | 'createSha256'
       | 'hmacSha256'
       | 'keccak256'
       | 'ripemd160'

package/src/wasm/Keystore.bench.ts

@@ -0,0 +1,26 @@
+import { scrypt as scrypt_noble } from '@noble/hashes/scrypt.js'
+import { bench, describe } from 'vp/test'
+import { engine as wasmEngine } from './Keystore.js'
+
+// Run `pnpm bench --project core src/wasm/Keystore.bench.ts`. These cases expose
+// the effect of block size, parallelization, and the public defaults.
+const cases = [
+  { N: 1024, dkLen: 32, p: 1, r: 1 },
+  { N: 16_384, dkLen: 32, p: 1, r: 8 },
+  { N: 262_144, dkLen: 32, p: 8, r: 1 },
+] as const
+
+const wasm = await wasmEngine()
+const password = new Uint8Array(16).fill(0x5a)
+const salt = new Uint8Array(32).fill(0xa5)
+
+for (const options of cases)
+  describe(`scrypt (N=${options.N}, r=${options.r}, p=${options.p})`, () => {
+    bench('ox', () => {
+      scrypt_noble(password, salt, options)
+    })
+
+    bench('ox/wasm', () => {
+      wasm.scrypt(password, salt, options)
+    })
+  })

package/src/wasm/Keystore.ts

@@ -1,21 +1,33 @@
 import type * as Engine from '../core/Engine.js'
 import type * as Errors from '../core/Errors.js'
-import * as hashes from './internal/hashes.js'
 import * as internal from './internal/instantiate.js'
-import * as pbkdf2 from './internal/pbkdf2.js'
+import * as keystore from './internal/keystore.js'
+import * as scrypt from './internal/scrypt.js'
 
 export * from '../core/Keystore.js'
 export { MemoryError } from './internal/instantiate.js'
 
 /**
- * Compiles the WASM implementation of the [`Keystore`](/api/Keystore) PBKDF2
- * primitive, without installing it.
+ * Compiles the WASM implementations of the [`Keystore`](/api/Keystore)
+ * synchronous key-derivation primitives, without installing them.
  *
- * Most callers want
- * [`Engine.install`](/wasm/crypto/Engine/install) instead, which compiles every
- * implementation this entrypoint provides and installs them in one call. This
- * provider deliberately stays synchronous and leaves AES, asynchronous PBKDF2,
- * and scrypt on Ox's default implementation.
+ * Most callers can use [`Engine.install`](/wasm/crypto/Engine/install).
+ * Install this factory explicitly when an application has benchmarked and
+ * selected WASM scrypt.
+ *
+ * This provider stays synchronous and leaves AES and asynchronous key
+ * derivation on Ox's default implementation.
+ *
+ * Scrypt uses a standalone artifact and grows memory only when called.
+ * WebAssembly cannot shrink that capacity. The provider clears its contents
+ * and enforces Noble's 1 GiB temporary-workspace limit.
+ *
+ * The aggregate [`Engine.install`](/wasm/crypto/Engine/install) installs only
+ * PBKDF2 from this provider. Install this factory explicitly to opt into
+ * scrypt, whose relative performance depends on its parameters and runtime.
+ *
+ * Copied inputs, derived output, and the complete workspace are cleared after
+ * every return or trap.
  *
  * @example
  * ```ts twoslash
@@ -25,16 +37,21 @@ export { MemoryError } from './internal/instantiate.js'
  *
  * await Engine.install({ Keystore: Keystore.engine() })
  *
- * Keystore.pbkdf2({ password: 'testpassword' })
+ * Keystore.scrypt({ password: 'testpassword' })
  * ```
  *
- * @returns The WASM implementation of synchronous PBKDF2-HMAC-SHA256.
+ * @returns The WASM implementations of synchronous PBKDF2-HMAC-SHA256 and
+ * scrypt.
  */
 export async function engine(): Promise<engine.ReturnType> {
-  const module = await hashes.load()
+  const [keystoreEngine, scryptModule] = await Promise.all([
+    keystore.engine(),
+    scrypt.load(),
+  ])
   return {
-    pbkdf2Sha256: (password, salt, options) =>
-      pbkdf2.pbkdf2Sha256(module, password, salt, options),
+    ...keystoreEngine,
+    scrypt: (password, salt, options) =>
+      scrypt.derive(scryptModule, password, salt, options),
   }
 }
 
@@ -42,6 +59,7 @@ export declare namespace engine {
   /** The WASM `Keystore` primitives this module implements. */
   type ReturnType = {
     pbkdf2Sha256: NonNullable<Engine.Keystore['pbkdf2Sha256']>
+    scrypt: NonNullable<Engine.Keystore['scrypt']>
   }
 
   type ErrorType = internal.MemoryError | Errors.GlobalErrorType

package/src/wasm/Kzg.bench.ts

@@ -0,0 +1,63 @@
+import { afterAll, bench, describe } from 'vp/test'
+import { mainnet as trustedSetup } from '../trusted-setups/Setups.js'
+import { create } from './Kzg.js'
+
+const once = {
+  iterations: 1,
+  time: 0,
+  warmupIterations: 0,
+  warmupTime: 0,
+} as const
+
+describe('create', () => {
+  bench(
+    'precompute 0',
+    async () => {
+      const kzg = await create({ trustedSetup })
+      kzg.dispose()
+    },
+    once,
+  )
+
+  bench(
+    'precompute 8',
+    async () => {
+      const kzg = await create({ precompute: 8, trustedSetup })
+      kzg.dispose()
+    },
+    once,
+  )
+})
+
+const kzg = await create({ trustedSetup })
+const blob = new Uint8Array(131_072)
+const commitment = kzg.blobToKzgCommitment(blob)
+const { cells, proofs } = kzg.computeCellsAndKzgProofs(blob)
+const indices = cells.map((_, index) => index)
+const commitments = cells.map(() => commitment)
+const partialIndices = indices.filter((index) => index % 2 === 0)
+const partialCells = cells.filter((_, index) => index % 2 === 0)
+
+afterAll(() => kzg.dispose())
+
+describe('operations', () => {
+  bench('blobToKzgCommitment', () => {
+    kzg.blobToKzgCommitment(blob)
+  })
+
+  bench('computeCells', () => {
+    kzg.computeCells(blob)
+  })
+
+  bench('computeCellsAndKzgProofs', () => {
+    kzg.computeCellsAndKzgProofs(blob)
+  })
+
+  bench('recoverCellsAndKzgProofs', () => {
+    kzg.recoverCellsAndKzgProofs(partialIndices, partialCells)
+  })
+
+  bench('verifyCellKzgProofBatch', () => {
+    kzg.verifyCellKzgProofBatch(commitments, indices, cells, proofs)
+  })
+})