ox 1.1.0 → 1.2.0

package/src/wasm/_test/Ed25519.test.ts

@@ -0,0 +1,168 @@
+import { ed25519 } from '@noble/curves/ed25519.js'
+import { describe, expect, test } from 'vp/test'
+import * as Ed25519 from '../Ed25519.js'
+import * as crypto25519 from '../internal/crypto25519.js'
+import { wasmBase64 } from '../internal/crypto25519.wasm.js'
+import * as ed25519_internal from '../internal/ed25519.js'
+import * as internal from '../internal/instantiate.js'
+
+const privateKey = fromHex(
+  '9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60',
+)
+
+describe('engine', () => {
+  test('behavior: exposes only semantics-compatible primitives', async () => {
+    const engine = await Ed25519.engine()
+
+    expect(Object.keys(engine).sort()).toMatchInlineSnapshot(`
+      [
+        "getPublicKey",
+        "sign",
+        "toMontgomerySecret",
+        "verify",
+      ]
+    `)
+  })
+
+  test('behavior: signs and verifies boundary-sized messages', async () => {
+    const engine = await Ed25519.engine()
+
+    for (const size of [0, 1, 31, 32, 63, 64, 65, 127, 128, 129, 1024]) {
+      const payload = Uint8Array.from(
+        { length: size },
+        (_, index) => (index * 29 + size) % 251,
+      )
+      const signature = engine.sign(payload, privateKey)
+      const publicKey = engine.getPublicKey(privateKey)
+
+      expect(signature).toEqual(ed25519.sign(payload, privateKey))
+      expect(engine.verify(signature, payload, publicKey)).toBe(true)
+      expect(
+        engine.verify(signature, Uint8Array.of(...payload, 1), publicKey),
+      ).toBe(false)
+    }
+  })
+
+  test('behavior: matches private-key conversion', async () => {
+    const engine = await Ed25519.engine()
+
+    expect(engine.toMontgomerySecret(privateKey)).toEqual(
+      ed25519.utils.toMontgomerySecret(privateKey),
+    )
+  })
+
+  test('behavior: respects subviews and leaves inputs immutable', async () => {
+    const engine = await Ed25519.engine()
+    const key = offsetView(privateKey)
+    const payload = offsetView(new Uint8Array(257).fill(0xa5))
+    const keyBefore = key.slice()
+    const payloadBefore = payload.slice()
+    const publicKey = offsetView(engine.getPublicKey(key))
+    const signature = offsetView(engine.sign(payload, key))
+    const publicKeyBefore = publicKey.slice()
+    const signatureBefore = signature.slice()
+
+    expect(engine.getPublicKey(key)).toEqual(ed25519.getPublicKey(key))
+    expect(engine.verify(signature, payload, publicKey)).toBe(true)
+    expect(engine.toMontgomerySecret(key)).toEqual(
+      ed25519.utils.toMontgomerySecret(key),
+    )
+    expect({ key, payload, publicKey, signature }).toEqual({
+      key: keyBefore,
+      payload: payloadBefore,
+      publicKey: publicKeyBefore,
+      signature: signatureBefore,
+    })
+  })
+
+  test('behavior: rejects malformed key and signature lengths', async () => {
+    const engine = await Ed25519.engine()
+    const publicKey = engine.getPublicKey(privateKey)
+
+    for (const size of [0, 1, 31, 33, 63, 64]) {
+      if (size !== 32) {
+        expect(() => engine.getPublicKey(new Uint8Array(size))).toThrowError(
+          `Ed25519 private key must be 32 bytes, got ${size}`,
+        )
+        expect(() =>
+          engine.sign(new Uint8Array(), new Uint8Array(size)),
+        ).toThrowError(`Ed25519 private key must be 32 bytes, got ${size}`)
+      }
+      if (size !== 64)
+        expect(() =>
+          engine.verify(new Uint8Array(size), new Uint8Array(), publicKey),
+        ).toThrowError(`Ed25519 signature must be 64 bytes, got ${size}`)
+    }
+
+    expect(() =>
+      engine.verify(new Uint8Array(64), new Uint8Array(), new Uint8Array(31)),
+    ).toThrowError('Ed25519 public key must be 32 bytes, got 31')
+  })
+
+  test('behavior: outputs are owned across calls and memory growth', async () => {
+    const engine = await Ed25519.engine()
+    const publicKey = engine.getPublicKey(privateKey)
+    const signature = engine.sign(new Uint8Array(), privateKey)
+    const snapshots = [publicKey.slice(), signature.slice()]
+
+    engine.sign(new Uint8Array(1024 * 1024).fill(0x5a), privateKey)
+
+    expect([publicKey, signature]).toEqual(snapshots)
+    expect(engine.getPublicKey(privateKey) === publicKey).toBe(false)
+  })
+
+  test('behavior: clears the shared staging region', async () => {
+    const engine = await Ed25519.engine()
+    const payload = new Uint8Array(1024).fill(0xa5)
+    engine.sign(payload, privateKey)
+
+    const module = await crypto25519.load()
+    const size = 32 + payload.length + 64
+    expect(
+      module
+        .view()
+        .subarray(module.heapBase, module.heapBase + size)
+        .every((byte) => byte === 0),
+    ).toBe(true)
+  })
+
+  test('behavior: clears the complete region after a late trap', async () => {
+    const module = await internal.instantiate<crypto25519.Exports>(wasmBase64)
+    const payload = new Uint8Array(1024).fill(0xa5)
+    const exports: crypto25519.Exports = {
+      ...module.exports,
+      ed25519_sign(...parameters) {
+        module.exports.ed25519_sign(...parameters)
+        throw new WebAssembly.RuntimeError('forced late trap')
+      },
+    }
+
+    expect(() =>
+      ed25519_internal.sign({ ...module, exports }, payload, privateKey),
+    ).toThrow(WebAssembly.RuntimeError)
+    expect(
+      module
+        .view()
+        .subarray(module.heapBase, module.heapBase + 32 + payload.length + 64)
+        .every((byte) => byte === 0),
+    ).toBe(true)
+  })
+
+  test('behavior: rejects a workspace beyond wasm32 without growing', async () => {
+    const module = await internal.instantiate<crypto25519.Exports>(wasmBase64)
+    const memory = module.view().length
+
+    expect(() => module.reserve(0x1_0000_0000)).toThrow(internal.MemoryError)
+    expect(module.view()).toHaveLength(memory)
+  })
+})
+
+function fromHex(value: string): Uint8Array {
+  return Uint8Array.from(Buffer.from(value, 'hex'))
+}
+
+function offsetView(value: Uint8Array): Uint8Array {
+  const bytes = new Uint8Array(value.length + 4).fill(0xff)
+  bytes.set(value, 2)
+  return bytes.subarray(2, -2)
+}

package/src/wasm/_test/Ed25519.vectors.test.ts

@@ -0,0 +1,73 @@
+import * as fs from 'node:fs'
+import { describe, expect, test } from 'vp/test'
+import * as Ed25519 from '../Ed25519.js'
+
+type Zip215Vector = {
+  sig_bytes: string
+  valid_legacy: boolean
+  valid_zip215: boolean
+  vk_bytes: string
+}
+
+const zip215 = JSON.parse(
+  fs.readFileSync(
+    new URL('../../../test/vectors/ed25519/zip215.json', import.meta.url),
+    'utf8',
+  ),
+) as readonly Zip215Vector[]
+
+const rfc8032 = [
+  {
+    message: '',
+    publicKey:
+      'd75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a',
+    seed: '9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60',
+    signature:
+      'e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b',
+  },
+  {
+    message: '72',
+    publicKey:
+      '3d4017c3e843895a92b70aa74d1b7ebc9c982ccf2ec4968cc0cd55f12af4660c',
+    seed: '4ccd089b28ff96da9db6c346ec114e0f5b8a319f35aba624da8cf6ed4fb8a6fb',
+    signature:
+      '92a009a9f0d4cab8720e820b5f642540a2b27b5416503f8fb3762223ebdb69da085ac1e43e15996e458f3613d0f11d8c387b2eaeb4302aeeb00d291612bb0c00',
+  },
+] as const
+
+describe('engine', () => {
+  test('vectors: matches RFC 8032 key, signature, and verification cases', async () => {
+    const engine = await Ed25519.engine()
+
+    for (const vector of rfc8032) {
+      const seed = fromHex(vector.seed)
+      const message = fromHex(vector.message)
+      const publicKey = fromHex(vector.publicKey)
+      const signature = fromHex(vector.signature)
+
+      expect(engine.getPublicKey(seed)).toEqual(publicKey)
+      expect(engine.sign(message, seed)).toEqual(signature)
+      expect(engine.verify(signature, message, publicKey)).toBe(true)
+    }
+  })
+
+  test('vectors: matches all 196 ZIP-215 compliance cases', async () => {
+    const engine = await Ed25519.engine()
+    const message = new TextEncoder().encode('Zcash')
+
+    expect(zip215).toHaveLength(196)
+    for (const vector of zip215)
+      expect(
+        engine.verify(
+          fromHex(vector.sig_bytes),
+          message,
+          fromHex(vector.vk_bytes),
+        ),
+        JSON.stringify(vector),
+      ).toBe(vector.valid_zip215)
+  })
+})
+
+function fromHex(value: string): Uint8Array {
+  return Uint8Array.from(Buffer.from(value, 'hex'))
+}

package/src/wasm/_test/Engine.test-d.ts

@@ -0,0 +1,29 @@
+import { Engine } from 'ox/wasm'
+import { expectTypeOf, test } from 'vp/test'
+import * as CoreEngine from '../../core/Engine.js'
+
+type Installed = Awaited<ReturnType<typeof Engine.install>>
+type Uninstalled = Awaited<ReturnType<typeof Engine.engine>>
+
+test('install and engine expose the same precise engine', () => {
+  expectTypeOf<Installed>().toEqualTypeOf<Uninstalled>()
+  expectTypeOf<Installed['Hash']['sha256']>().toEqualTypeOf<
+    (input: Uint8Array) => Uint8Array
+  >()
+  expectTypeOf<Installed['Keystore']>().not.toHaveProperty('scrypt')
+})
+
+test('the WASM Engine namespace exposes synchronous core operations', () => {
+  expectTypeOf(Engine.get).toEqualTypeOf(CoreEngine.get)
+  expectTypeOf(Engine.InvalidSlotValueError).toEqualTypeOf(
+    CoreEngine.InvalidSlotValueError,
+  )
+  expectTypeOf(Engine.reset).toEqualTypeOf(CoreEngine.reset)
+  expectTypeOf(Engine.set).toEqualTypeOf(CoreEngine.set)
+  expectTypeOf(Engine.with).toEqualTypeOf(CoreEngine.with)
+})
+
+test('the replaced aliases are absent', () => {
+  expectTypeOf<typeof Engine>().not.toHaveProperty('create')
+  expectTypeOf<typeof Engine>().not.toHaveProperty('load')
+})

package/src/wasm/_test/Engine.test.ts

@@ -1,62 +1,96 @@
-import { Engine as CoreEngine, Hash } from 'ox'
-import { Engine } from 'ox/wasm'
+import { Engine as CoreEngine } from 'ox'
+import { Engine, Hash } from 'ox/wasm'
 import { describe, expect, test } from 'vp/test'
 
-describe('create', () => {
+describe('engine', () => {
   test('behavior: does not install', async () => {
-    const engine = await Engine.create()
+    const engine = await Engine.engine()
     expect(Object.keys(engine)).toMatchInlineSnapshot(`
       [
+        "Ed25519",
         "Hash",
+        "Keystore",
+        "Mnemonic",
+        "X25519",
       ]
     `)
-    // The whole point of `create` over `load`: benches, differential tests and
-    // composition all need the implementation without touching global state.
+    // Benches, differential tests, and composition need an implementation
+    // value without touching global state.
     expect(CoreEngine.get()).toMatchInlineSnapshot('{}')
   })
 
   test('behavior: installs for the duration of a call', async () => {
     // `with` is the case that genuinely needs a value: there is nothing
     // installed for `set` to merge into.
-    const wasm = await Engine.create()
-    const inside = CoreEngine.with(wasm, () => Hash.keccak256('0xdeadbeef'))
-    expect(inside).toEqual(Hash.keccak256('0xdeadbeef'))
+    const wasm = await Engine.engine()
+    const inside = CoreEngine.with(wasm, () => Hash.sha256('0xdeadbeef'))
+    expect(inside).toEqual(Hash.sha256('0xdeadbeef'))
     expect(CoreEngine.get()).toMatchInlineSnapshot('{}')
   })
 })
 
-describe('load', () => {
+describe('install', () => {
   test('behavior: merges with a later set, rather than being replaced', async () => {
-    await Engine.load()
-    CoreEngine.set({ Mnemonic: { toSeed: () => new Uint8Array(64) } })
+    await Engine.install()
+    CoreEngine.set({ Bls: { randomSecretKey: () => new Uint8Array(32) } })
     expect(Object.keys(CoreEngine.get()).sort()).toMatchInlineSnapshot(`
       [
+        "Bls",
+        "Ed25519",
         "Hash",
+        "Keystore",
         "Mnemonic",
+        "X25519",
       ]
     `)
   })
 
   test('behavior: installs, and returns what it installed', async () => {
-    const before = Hash.keccak256('0xdeadbeef')
+    const before = Hash.sha256('0xdeadbeef')
 
-    const engine = await Engine.load()
+    const engine = await Engine.install()
 
     expect(Object.keys(CoreEngine.get())).toEqual(Object.keys(engine))
     // Installing changes which implementation runs, never the answer.
-    expect(Hash.keccak256('0xdeadbeef')).toEqual(before)
+    expect(Hash.sha256('0xdeadbeef')).toEqual(before)
+    expect(Engine.get()).toEqual(CoreEngine.get())
   })
 
   test('behavior: routes every slot it reports', async () => {
-    await Engine.load()
-    expect(Object.keys(CoreEngine.get().Hash ?? {}).sort())
-      .toMatchInlineSnapshot(`
-      [
-        "hmacSha256",
-        "keccak256",
-        "ripemd160",
-        "sha256",
-      ]
-    `)
+    await Engine.install()
+    expect(
+      Object.fromEntries(
+        Object.entries(CoreEngine.get()).map(([slot, value]) => [
+          slot,
+          Object.keys(value ?? {}).sort(),
+        ]),
+      ),
+    ).toMatchInlineSnapshot(`
+        {
+          "Ed25519": [
+            "getPublicKey",
+            "sign",
+            "toMontgomerySecret",
+            "verify",
+          ],
+          "Hash": [
+            "blake3",
+            "hmacSha256",
+            "keccak256",
+            "ripemd160",
+            "sha256",
+          ],
+          "Keystore": [
+            "pbkdf2Sha256",
+          ],
+          "Mnemonic": [
+            "toSeed",
+          ],
+          "X25519": [
+            "getPublicKey",
+            "getSharedSecret",
+          ],
+        }
+      `)
   })
 })

package/src/wasm/_test/Hash.browser.test.ts

@@ -1,10 +1,11 @@
+import { blake3 } from '@noble/hashes/blake3.js'
 import { keccak_256 } from '@noble/hashes/sha3.js'
 import { describe, expect, test, vi } from 'vp/test'
 import * as Engine from '../../core/Engine.js'
 import * as Hash from '../../core/Hash.js'
 import * as WasmHash from '../Hash.js'
 
-describe('create', () => {
+describe('engine', () => {
   test('behavior: instantiates asynchronously', async () => {
     // Chrome refuses to compile modules above a few kilobytes synchronously on
     // the main thread, so `new WebAssembly.Module` must never be reached. A spy
@@ -13,12 +14,13 @@ describe('create', () => {
     const Module = vi.spyOn(globalThis.WebAssembly, 'Module')
     const Instance = vi.spyOn(globalThis.WebAssembly, 'Instance')
     try {
-      const engine = await WasmHash.create()
+      const engine = await WasmHash.engine()
       expect(Module).not.toHaveBeenCalled()
       expect(Instance).not.toHaveBeenCalled()
 
       const input = new Uint8Array(32).fill(1)
-      expect(engine.Hash.keccak256(input)).toEqual(keccak_256(input))
+      expect(engine.keccak256(input)).toEqual(keccak_256(input))
+      expect(engine.blake3(input)).toEqual(blake3(input))
     } finally {
       Module.mockRestore()
       Instance.mockRestore()
@@ -26,20 +28,25 @@ describe('create', () => {
   })
 
   test('behavior: grows memory in a real browser, then hashes a small input', async () => {
-    const engine = await WasmHash.create()
+    const engine = await WasmHash.engine()
 
     const large = new Uint8Array(3 * 1024 * 1024).fill(7)
-    expect(engine.Hash.keccak256(large)).toEqual(keccak_256(large))
+    expect(engine.keccak256(large)).toEqual(keccak_256(large))
+    expect(engine.blake3(large)).toEqual(blake3(large))
 
     // `memory.grow` detached the previous `ArrayBuffer`; a retained view would
     // now read zero bytes.
     const small = new Uint8Array(32).fill(1)
-    expect(engine.Hash.keccak256(small)).toEqual(keccak_256(small))
+    expect(engine.keccak256(small)).toEqual(keccak_256(small))
+    expect(engine.blake3(small)).toEqual(blake3(small))
   })
 
   test('behavior: ox uses the WASM implementation once installed', async () => {
-    Engine.set(await WasmHash.create())
+    await Engine.install({ Hash: WasmHash.engine() })
     try {
+      expect(Hash.blake3('0xdeadbeef')).toBe(
+        '0x53147f3ce49ed4f60dfa5b9654c36ba6103c11f5737df3dabd4cbd296c4161bd',
+      )
       expect(Hash.keccak256('0xdeadbeef')).toBe(
         '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1',
       )

package/src/wasm/_test/Hash.fuzz.ts

@@ -1,4 +1,5 @@
 import { fc, test } from '@fast-check/vitest'
+import { blake3 } from '@noble/hashes/blake3.js'
 import { hmac } from '@noble/hashes/hmac.js'
 import { ripemd160 } from '@noble/hashes/legacy.js'
 import { sha256 } from '@noble/hashes/sha2.js'
@@ -7,10 +8,10 @@ import { Hash as WasmHash } from 'ox/wasm'
 import { beforeAll, describe, expect } from 'vp/test'
 import { numRuns } from '../../../test/fuzz/numRuns.js'
 
-let engine: WasmHash.create.ReturnType
+let engine: WasmHash.engine.ReturnType
 
 beforeAll(async () => {
-  engine = await WasmHash.create()
+  engine = await WasmHash.engine()
 })
 
 /**
@@ -21,14 +22,33 @@ beforeAll(async () => {
  *
  * The distribution is weighted toward the sizes where padding and block-boundary
  * bugs hide -- empty input, exact multiples of the keccak256 rate (136) and the
- * SHA-2 block (64), and the 56-byte threshold at which the length counter no
- * longer fits in the final block.
+ * SHA-2 block (64), BLAKE3 chunk (1024), and the 56-byte threshold at which
+ * the SHA-2 length counter no longer fits in the final block.
  */
 const arbitraryInput = fc.oneof(
   { arbitrary: fc.uint8Array({ maxLength: 300, minLength: 0 }), weight: 6 },
   {
     arbitrary: fc
-      .constantFrom(0, 1, 55, 56, 63, 64, 65, 111, 112, 135, 136, 137, 272)
+      .constantFrom(
+        0,
+        1,
+        55,
+        56,
+        63,
+        64,
+        65,
+        111,
+        112,
+        135,
+        136,
+        137,
+        272,
+        1023,
+        1024,
+        1025,
+        2048,
+        2049,
+      )
       .chain((size) => fc.uint8Array({ maxLength: size, minLength: size })),
     weight: 3,
   },
@@ -54,55 +74,63 @@ const arbitraryKey = fc.oneof(
 )
 
 const primitives = {
+  blake3: {
+    reference: (input: Uint8Array) => blake3(input),
+    wasm: (input: Uint8Array) => engine.blake3(input),
+  },
   hmacSha256: {
     reference: (input: Uint8Array, key: Uint8Array) => hmac(sha256, key, input),
-    wasm: (input: Uint8Array, key: Uint8Array) =>
-      engine.Hash.hmacSha256(key, input),
+    wasm: (input: Uint8Array, key: Uint8Array) => engine.hmacSha256(key, input),
   },
   keccak256: {
     reference: (input: Uint8Array) => keccak_256(input),
-    wasm: (input: Uint8Array) => engine.Hash.keccak256(input),
+    wasm: (input: Uint8Array) => engine.keccak256(input),
   },
   ripemd160: {
     reference: (input: Uint8Array) => ripemd160(input),
-    wasm: (input: Uint8Array) => engine.Hash.ripemd160(input),
+    wasm: (input: Uint8Array) => engine.ripemd160(input),
   },
   sha256: {
     reference: (input: Uint8Array) => sha256(input),
-    wasm: (input: Uint8Array) => engine.Hash.sha256(input),
+    wasm: (input: Uint8Array) => engine.sha256(input),
   },
 } as const
 
 type Name = keyof typeof primitives
 
 describe('Hash', () => {
+  test.prop({ input: arbitraryInput }, { numRuns })(
+    'blake3 ≡ @noble/hashes',
+    ({ input }) => {
+      expect(engine.blake3(input)).toEqual(blake3(input))
+    },
+  )
+
   test.prop({ input: arbitraryInput }, { numRuns })(
     'keccak256 ≡ @noble/hashes',
     ({ input }) => {
-      expect(engine.Hash.keccak256(input)).toEqual(keccak_256(input))
+      expect(engine.keccak256(input)).toEqual(keccak_256(input))
     },
   )
 
   test.prop({ input: arbitraryInput }, { numRuns })(
     'sha256 ≡ @noble/hashes',
     ({ input }) => {
-      expect(engine.Hash.sha256(input)).toEqual(sha256(input))
+      expect(engine.sha256(input)).toEqual(sha256(input))
     },
   )
 
   test.prop({ input: arbitraryInput }, { numRuns })(
     'ripemd160 ≡ @noble/hashes',
     ({ input }) => {
-      expect(engine.Hash.ripemd160(input)).toEqual(ripemd160(input))
+      expect(engine.ripemd160(input)).toEqual(ripemd160(input))
     },
   )
 
   test.prop({ input: arbitraryInput, key: arbitraryKey }, { numRuns })(
     'hmacSha256 ≡ @noble/hashes',
     ({ input, key }) => {
-      expect(engine.Hash.hmacSha256(key, input)).toEqual(
-        hmac(sha256, key, input),
-      )
+      expect(engine.hmacSha256(key, input)).toEqual(hmac(sha256, key, input))
     },
   )
 })
@@ -115,6 +143,7 @@ describe('memory', () => {
           input: arbitraryInput,
           key: arbitraryKey,
           name: fc.constantFrom<Name>(
+            'blake3',
             'hmacSha256',
             'keccak256',
             'ripemd160',
@@ -156,7 +185,7 @@ describe('memory', () => {
     // as zeroes rather than throwing.
     for (const pages of sizes) {
       const input = new Uint8Array(pages * 65_536).fill(pages & 0xff)
-      expect(engine.Hash.keccak256(input), `${pages} pages`).toEqual(
+      expect(engine.keccak256(input), `${pages} pages`).toEqual(
         keccak_256(input),
       )
     }
@@ -167,10 +196,15 @@ describe('memory', () => {
     ({ input }) => {
       // A digest returned as a view over linear memory would be silently
       // rewritten by the next call. Hold one across a larger call and check it.
-      const digest = engine.Hash.keccak256(input)
+      const digest = engine.keccak256(input)
       const snapshot = digest.slice()
-      engine.Hash.keccak256(new Uint8Array(input.length + 1024).fill(0xaa))
+      engine.keccak256(new Uint8Array(input.length + 1024).fill(0xaa))
       expect(digest).toEqual(snapshot)
+
+      const blake3Digest = engine.blake3(input)
+      const blake3Snapshot = blake3Digest.slice()
+      engine.blake3(new Uint8Array(input.length + 1024).fill(0xaa))
+      expect(blake3Digest).toEqual(blake3Snapshot)
     },
   )
 
@@ -178,10 +212,11 @@ describe('memory', () => {
     'inputs are not mutated',
     ({ input }) => {
       const snapshot = input.slice()
-      engine.Hash.keccak256(input)
-      engine.Hash.sha256(input)
-      engine.Hash.ripemd160(input)
-      engine.Hash.hmacSha256(input, input)
+      engine.blake3(input)
+      engine.keccak256(input)
+      engine.sha256(input)
+      engine.ripemd160(input)
+      engine.hmacSha256(input, input)
       expect(input).toEqual(snapshot)
     },
   )

package/src/wasm/_test/Hash.test-d.ts

@@ -1,28 +1,34 @@
-import type { Engine } from 'ox'
 import { Hash as WasmHash } from 'ox/wasm'
 import { expectTypeOf, test } from 'vp/test'
+import type * as CoreEngine from '../../core/Engine.js'
+import * as CoreHash from '../../core/Hash.js'
 
-type Created = Awaited<ReturnType<typeof WasmHash.create>>
+type Slot = Awaited<ReturnType<typeof WasmHash.engine>>
 
 test('every primitive is present, so callers need no assertion', () => {
-  expectTypeOf<Created['Hash']['keccak256']>().toEqualTypeOf<
+  expectTypeOf<Slot['blake3']>().toEqualTypeOf<
     (input: Uint8Array) => Uint8Array
   >()
-  expectTypeOf<Created['Hash']['sha256']>().toEqualTypeOf<
+  expectTypeOf<Slot['keccak256']>().toEqualTypeOf<
     (input: Uint8Array) => Uint8Array
   >()
-  expectTypeOf<Created['Hash']['ripemd160']>().toEqualTypeOf<
+  expectTypeOf<Slot['sha256']>().toEqualTypeOf<
     (input: Uint8Array) => Uint8Array
   >()
-  expectTypeOf<Created['Hash']['hmacSha256']>().toEqualTypeOf<
+  expectTypeOf<Slot['ripemd160']>().toEqualTypeOf<
+    (input: Uint8Array) => Uint8Array
+  >()
+  expectTypeOf<Slot['hmacSha256']>().toEqualTypeOf<
     (key: Uint8Array, message: Uint8Array) => Uint8Array
   >()
 })
 
-test('blake3 is absent, because the WASM module does not implement it', () => {
-  expectTypeOf<Created['Hash']>().not.toHaveProperty('blake3')
+test('the result is the raw slot, so `Engine.install` accepts it', () => {
+  expectTypeOf<{ Hash: Slot }>().toExtend<CoreEngine.Engine>()
 })
 
-test('the result is still an engine, so `Engine.set` accepts it', () => {
-  expectTypeOf<Created>().toExtend<Engine.Engine>()
+test('the WASM namespace exposes the public Hash API', () => {
+  expectTypeOf(WasmHash.blake3).toEqualTypeOf(CoreHash.blake3)
+  expectTypeOf(WasmHash.sha256).toEqualTypeOf(CoreHash.sha256)
+  expectTypeOf<typeof WasmHash>().not.toHaveProperty('create')
 })