ox 1.1.0 → 1.1.2

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

@@ -0,0 +1,187 @@
+import { fc, test } from '@fast-check/vitest'
+import { ed25519, x25519 } from '@noble/curves/ed25519.js'
+import { mnemonicToSeedSync } from '@scure/bip39'
+import { beforeAll, describe, expect } from 'vp/test'
+import { numRuns } from '../../../test/fuzz/numRuns.js'
+import * as Ed25519 from '../Ed25519.js'
+import * as Mnemonic from '../Mnemonic.js'
+import * as X25519 from '../X25519.js'
+import { x25519LowOrder } from './fixtures.js'
+
+let ed25519Engine: Ed25519.engine.ReturnType
+let mnemonicEngine: Mnemonic.engine.ReturnType
+let x25519Engine: X25519.engine.ReturnType
+
+beforeAll(async () => {
+  ed25519Engine = await Ed25519.engine()
+  mnemonicEngine = await Mnemonic.engine()
+  x25519Engine = await X25519.engine()
+})
+
+const arbitraryKey = fc.uint8Array({ maxLength: 32, minLength: 32 })
+const arbitraryPayload = fc.oneof(
+  fc.uint8Array({ maxLength: 512 }),
+  fc
+    .constantFrom(0, 1, 31, 32, 63, 64, 65, 127, 128, 129, 1024, 4096)
+    .chain((size) => fc.uint8Array({ maxLength: size, minLength: size })),
+)
+const arbitraryWord = fc.oneof(
+  fc
+    .string({ maxLength: 16, minLength: 1 })
+    .filter((value) => !value.normalize('NFKD').includes(' ')),
+  fc.constantFrom('café', 'cafe\u0301', 'あおぞら', '㍍ガバヴァ'),
+)
+const arbitraryMnemonic = fc
+  .tuple(
+    fc.constantFrom(12, 15, 18, 21, 24),
+    fc.array(arbitraryWord, { maxLength: 24, minLength: 24 }),
+  )
+  .map(([count, words]) => words.slice(0, count).join(' '))
+
+describe('Ed25519', () => {
+  test.prop(
+    { payload: arbitraryPayload, privateKey: arbitraryKey },
+    { numRuns },
+  )('matches the default for arbitrary subviews', (options) => {
+    const payload = offsetView(options.payload)
+    const privateKey = offsetView(options.privateKey)
+    const publicKey = ed25519Engine.getPublicKey(privateKey)
+    const signature = ed25519Engine.sign(payload, privateKey)
+
+    expect(publicKey).toEqual(ed25519.getPublicKey(privateKey))
+    expect(signature).toEqual(ed25519.sign(payload, privateKey))
+    expect(ed25519Engine.verify(signature, payload, publicKey)).toBe(true)
+    expect(
+      ed25519Engine.verify(signature, Uint8Array.of(...payload, 1), publicKey),
+    ).toBe(false)
+    expect(ed25519Engine.toMontgomerySecret(privateKey)).toEqual(
+      ed25519.utils.toMontgomerySecret(privateKey),
+    )
+  })
+
+  test.prop(
+    {
+      payload: arbitraryPayload,
+      publicKey: arbitraryKey,
+      signature: fc.uint8Array({ maxLength: 64, minLength: 64 }),
+    },
+    { numRuns },
+  )('verification matches ZIP-215 for arbitrary encodings', (options) => {
+    expect(
+      ed25519Engine.verify(
+        options.signature,
+        options.payload,
+        options.publicKey,
+      ),
+    ).toBe(
+      ed25519.verify(options.signature, options.payload, options.publicKey),
+    )
+  })
+})
+
+describe('X25519', () => {
+  test.prop(
+    { privateKey: arbitraryKey, publicKeySeed: arbitraryKey },
+    { numRuns },
+  )('matches the default for arbitrary subviews', (options) => {
+    const privateKey = offsetView(options.privateKey)
+    const publicKey = offsetView(x25519.getPublicKey(options.publicKeySeed))
+
+    expect(x25519Engine.getPublicKey(privateKey)).toEqual(
+      x25519.getPublicKey(privateKey),
+    )
+    expect(x25519Engine.getSharedSecret(privateKey, publicKey)).toEqual(
+      x25519.getSharedSecret(privateKey, publicKey),
+    )
+  })
+
+  test.prop(
+    {
+      highBit: fc.boolean(),
+      privateKey: arbitraryKey,
+      vector: fc.constantFrom(...x25519LowOrder),
+    },
+    { numRuns },
+  )(
+    'rejects arbitrary private keys paired with low-order points',
+    (options) => {
+      const publicKey = fromHex(options.vector.publicKey)
+      if (options.highBit) publicKey[31]! |= 0x80
+      expect(() =>
+        x25519Engine.getSharedSecret(options.privateKey, publicKey),
+      ).toThrow()
+    },
+  )
+})
+
+describe('Mnemonic', () => {
+  test.prop(
+    {
+      mnemonic: arbitraryMnemonic,
+      passphrase: fc.string({ maxLength: 64 }),
+    },
+    { numRuns },
+  )('matches the default for arbitrary normalized text', (options) => {
+    expect(mnemonicEngine.toSeed(options.mnemonic, options.passphrase)).toEqual(
+      mnemonicToSeedSync(options.mnemonic, options.passphrase),
+    )
+  })
+})
+
+describe('memory', () => {
+  test.prop(
+    {
+      operations: fc.array(
+        fc.record({
+          payload: arbitraryPayload,
+          privateKey: arbitraryKey,
+          publicKeySeed: arbitraryKey,
+        }),
+        { maxLength: 8, minLength: 2 },
+      ),
+    },
+    { numRuns },
+  )(
+    'interleaved providers remain isolated and outputs stay owned',
+    (options) => {
+      const held: Uint8Array[] = []
+      const snapshots: Uint8Array[] = []
+
+      for (const operation of options.operations) {
+        const edPublicKey = ed25519Engine.getPublicKey(operation.privateKey)
+        const signature = ed25519Engine.sign(
+          operation.payload,
+          operation.privateKey,
+        )
+        const xPublicKey = x25519.getPublicKey(operation.publicKeySeed)
+        const sharedSecret = x25519Engine.getSharedSecret(
+          operation.privateKey,
+          xPublicKey,
+        )
+        expect(
+          ed25519Engine.verify(signature, operation.payload, edPublicKey),
+        ).toBe(true)
+        expect(sharedSecret).toEqual(
+          x25519.getSharedSecret(operation.privateKey, xPublicKey),
+        )
+        held.push(signature, sharedSecret)
+        snapshots.push(signature.slice(), sharedSecret.slice())
+      }
+
+      expect(held).toEqual(snapshots)
+    },
+  )
+})
+
+function offsetView(value: Uint8Array): Uint8Array {
+  const bytes = new Uint8Array(value.length + 4).fill(0xff)
+  bytes.set(value, 2)
+  return bytes.subarray(2, -2)
+}
+
+function fromHex(value: string): Uint8Array {
+  const bytes = new Uint8Array(value.length / 2)
+  for (let index = 0; index < bytes.length; index++)
+    bytes[index] = Number.parseInt(value.slice(index * 2, index * 2 + 2), 16)
+  return bytes
+}

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

@@ -0,0 +1,28 @@
+import { expectTypeOf, test } from 'vp/test'
+import type * as Engine from '../../core/Engine.js'
+import * as core_Ed25519 from '../../core/Ed25519.js'
+import * as Ed25519 from '../Ed25519.js'
+
+type Slot = Awaited<ReturnType<typeof Ed25519.engine>>
+
+test('return type exposes only implemented Ed25519 primitives', () => {
+  expectTypeOf<Slot['getPublicKey']>().toEqualTypeOf<
+    NonNullable<Engine.Eddsa['getPublicKey']>
+  >()
+  expectTypeOf<Slot['sign']>().toEqualTypeOf<
+    NonNullable<Engine.Eddsa['sign']>
+  >()
+  expectTypeOf<Slot['toMontgomerySecret']>().toEqualTypeOf<
+    NonNullable<Engine.Eddsa['toMontgomerySecret']>
+  >()
+  expectTypeOf<Slot['verify']>().toEqualTypeOf<
+    NonNullable<Engine.Eddsa['verify']>
+  >()
+  expectTypeOf<Slot>().not.toHaveProperty('randomSecretKey')
+  expectTypeOf<Slot>().not.toHaveProperty('toMontgomery')
+})
+
+test('the WASM namespace exposes the public Ed25519 API', () => {
+  expectTypeOf(Ed25519.getPublicKey).toEqualTypeOf(core_Ed25519.getPublicKey)
+  expectTypeOf<typeof Ed25519>().not.toHaveProperty('create')
+})

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,28 @@
+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
+  >()
+})
+
+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,19 +28,21 @@ 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.keccak256('0xdeadbeef')).toBe(
         '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1',