ox 1.0.4 → 1.1.0

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

@@ -0,0 +1,211 @@
+import { hmac } from '@noble/hashes/hmac.js'
+import { ripemd160 } from '@noble/hashes/legacy.js'
+import { sha256 } from '@noble/hashes/sha2.js'
+import { keccak_256 } from '@noble/hashes/sha3.js'
+import { Bytes, Engine, Hash } from 'ox'
+import { Hash as WasmHash } from 'ox/wasm'
+import { beforeAll, describe, expect, test } from 'vp/test'
+import { hmacSha256ScratchSize, wasmBase64 } from '../internal/hashes.wasm.js'
+import * as hash from '../internal/hash.js'
+import * as internal from '../internal/instantiate.js'
+
+let engine: WasmHash.create.ReturnType
+
+beforeAll(async () => {
+  engine = await WasmHash.create()
+})
+
+describe('create', () => {
+  test('default', async () => {
+    expect(Object.keys(await WasmHash.create())).toMatchInlineSnapshot(`
+      [
+        "Hash",
+      ]
+    `)
+    expect(Object.keys((await WasmHash.create()).Hash)).toMatchInlineSnapshot(`
+      [
+        "hmacSha256",
+        "keccak256",
+        "ripemd160",
+        "sha256",
+      ]
+    `)
+  })
+
+  test('behavior: hands every caller its own engine', async () => {
+    const [a, b] = await Promise.all([WasmHash.create(), WasmHash.create()])
+
+    // Deliberately not the same object. A shared slot lets one caller's
+    // customisation for composition leak into what a later `create` -- or
+    // `Engine.load` -- installs.
+    expect(a).not.toBe(b)
+    expect(a.Hash).not.toBe(b.Hash)
+
+    a.Hash.keccak256 = () => new Uint8Array(32).fill(9)
+    const c = await WasmHash.create()
+    expect(c.Hash.keccak256(Bytes.from('0xdeadbeef'))).toEqual(
+      b.Hash.keccak256(Bytes.from('0xdeadbeef')),
+    )
+  })
+})
+
+// Sizes chosen around the block boundaries where padding bugs live: keccak256's
+// rate is 136 bytes, sha256 and ripemd160 use 64-byte blocks and need a second
+// block once the remainder reaches 56.
+const sizes = [
+  0, 1, 2, 31, 32, 55, 56, 63, 64, 65, 71, 72, 111, 135, 136, 137, 199, 200,
+  271, 272, 1000,
+]
+
+function input(size: number) {
+  return new Uint8Array(size).map((_, index) => (index * 37 + 11) & 0xff)
+}
+
+describe('Hash', () => {
+  test.each(sizes)('keccak256 matches the default at %i bytes', (size) => {
+    expect(engine.Hash.keccak256(input(size))).toEqual(keccak_256(input(size)))
+  })
+
+  test.each(sizes)('sha256 matches the default at %i bytes', (size) => {
+    expect(engine.Hash.sha256(input(size))).toEqual(sha256(input(size)))
+  })
+
+  test.each(sizes)('ripemd160 matches the default at %i bytes', (size) => {
+    expect(engine.Hash.ripemd160(input(size))).toEqual(ripemd160(input(size)))
+  })
+
+  test.each([0, 1, 32, 63, 64, 65, 200])(
+    'hmacSha256 matches the default with a %i byte key',
+    (size) => {
+      const key = new Uint8Array(size).fill(0xa5)
+      const message = input(100)
+      expect(engine.Hash.hmacSha256(key, message)).toEqual(
+        hmac(sha256, key, message),
+      )
+    },
+  )
+
+  test('behavior: known vectors', () => {
+    expect(Bytes.toHex(engine.Hash.keccak256(new Uint8Array(0)))).toBe(
+      '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470',
+    )
+    expect(Bytes.toHex(engine.Hash.sha256(new Uint8Array(0)))).toBe(
+      '0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+    )
+    expect(Bytes.toHex(engine.Hash.ripemd160(new Uint8Array(0)))).toBe(
+      '0x9c1185a5c5e9fc54612808977ee8f548b2258d31',
+    )
+  })
+
+  test('behavior: grows memory past 64 MiB, then still hashes small inputs', () => {
+    // The input itself is exactly 64 MiB, so the heap base and digest force
+    // memory past that boundary. Growing detaches the previous `ArrayBuffer`; a
+    // retained view would silently read zero bytes in the assertion below.
+    const large = new Uint8Array(64 * 1024 * 1024).fill(7)
+    expect(engine.Hash.sha256(large)).toEqual(sha256(large))
+
+    const small = input(32)
+    expect(engine.Hash.sha256(small)).toEqual(sha256(small))
+  })
+
+  test('behavior: hmacSha256 clears its complete memory region', async () => {
+    const module = await internal.instantiate<hash.Exports>(wasmBase64)
+    const key = input(120)
+    const message = input(17)
+    const out = 32
+    const messagePtr = module.heapBase
+    const keyPtr = messagePtr + message.length
+    const outPtr = keyPtr + key.length
+    const scratchPtr = Math.ceil((outPtr + out) / 4) * 4
+    const end = scratchPtr + hmacSha256ScratchSize
+    const stack = module.view().slice(0, module.heapBase)
+
+    expect(hash.hmacSha256(module, key, message)).toEqual(
+      hmac(sha256, key, message),
+    )
+
+    expect(module.view().slice(0, module.heapBase)).toEqual(stack)
+    expect(module.view().slice(messagePtr, end)).toEqual(
+      new Uint8Array(end - messagePtr),
+    )
+  })
+
+  test('behavior: hmacSha256 clears its complete region after a trap', async () => {
+    const module = await internal.instantiate<hash.Exports>(wasmBase64)
+    const key = input(120)
+    const message = input(17)
+    const out = 32
+    const messagePtr = module.heapBase
+    const keyPtr = messagePtr + message.length
+    const validOutPtr = keyPtr + key.length
+    const scratchPtr = Math.ceil((validOutPtr + out) / 4) * 4
+    const end = scratchPtr + hmacSha256ScratchSize
+    const stack = module.view().slice(0, module.heapBase)
+    // Preserve the production boundary while making the real export trap only
+    // after it has populated the scratch buffer.
+    const exports = {
+      hmac_sha256(
+        keyPtr: number,
+        keyLength: number,
+        messagePtr: number,
+        messageLength: number,
+        _outPtr: number,
+        scratchPtr: number,
+      ) {
+        module.exports.hmac_sha256(
+          keyPtr,
+          keyLength,
+          messagePtr,
+          messageLength,
+          module.view().length - 16,
+          scratchPtr,
+        )
+      },
+      zero: (ptr: number, length: number) => module.exports.zero(ptr, length),
+    }
+    const trappingModule = { ...module, exports }
+
+    expect(() => hash.hmacSha256(trappingModule, key, message)).toThrow(
+      WebAssembly.RuntimeError,
+    )
+    expect(module.view().slice(0, module.heapBase)).toEqual(stack)
+    expect(module.view().slice(messagePtr, end)).toEqual(
+      new Uint8Array(end - messagePtr),
+    )
+
+    module.exports.zero(module.view().length - 16, 16)
+    expect(hash.hmacSha256(module, key, message)).toEqual(
+      hmac(sha256, key, message),
+    )
+  })
+
+  test('behavior: consecutive calls do not corrupt each other', () => {
+    const a = input(200)
+    const b = input(7)
+    expect(engine.Hash.keccak256(a)).toEqual(keccak_256(a))
+    expect(engine.Hash.keccak256(b)).toEqual(keccak_256(b))
+    expect(engine.Hash.keccak256(a)).toEqual(keccak_256(a))
+  })
+
+  test('behavior: results do not alias WASM memory', () => {
+    const first = engine.Hash.keccak256(input(32))
+    const snapshot = first.slice()
+    engine.Hash.keccak256(input(64))
+    expect(first).toEqual(snapshot)
+  })
+})
+
+describe('Engine.set', () => {
+  test('behavior: ox uses the WASM implementation once installed', () => {
+    Engine.set(engine)
+    expect(Hash.keccak256('0xdeadbeef')).toBe(
+      '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1',
+    )
+    expect(Hash.sha256('0xdeadbeef')).toBe(
+      '0x5f78c33274e43fa9de5659265c1d917e25c03722dcb0b8d27db8d5feaa813953',
+    )
+    expect(Hash.ripemd160('0xdeadbeef')).toBe(
+      '0x226821c2f5423e11fe9af68bd285c249db2e4b5a',
+    )
+  })
+})

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

@@ -0,0 +1,117 @@
+import { Hash as WasmHash } from 'ox/wasm'
+import { beforeAll, describe, expect, test } from 'vp/test'
+import * as vectors from '../../../test/vectors/hashes/index.js'
+import { wasmBase64 } from '../internal/hashes.wasm.js'
+import { instantiate } from '../internal/instantiate.js'
+
+/**
+ * Published vectors against the WASM implementations.
+ *
+ * The differential tests in `Hash.test.ts` and `Hash.fuzz.ts` prove the WASM
+ * agrees with `@noble/hashes`. These prove it agrees with the specifications, so
+ * a fault the two implementations happened to share would still be caught.
+ * See `test/vectors/hashes/README.md`.
+ */
+
+let engine: WasmHash.create.ReturnType
+
+beforeAll(async () => {
+  engine = await WasmHash.create()
+})
+
+describe('sha256', () => {
+  test(`matches ${vectors.sha256.length} NIST CAVP vectors`, () => {
+    for (const { digest, message } of vectors.sha256)
+      expect(engine.Hash.sha256(message)).toEqual(digest)
+  })
+})
+
+describe('hmacSha256', () => {
+  test(`matches ${vectors.hmacSha256.length} RFC 4231 vectors`, () => {
+    // Two of these use 131-byte keys, which is the only coverage of the
+    // longer-than-a-block path where the key is hashed before padding.
+    for (const { digest, key, message } of vectors.hmacSha256)
+      expect(engine.Hash.hmacSha256(key, message)).toEqual(digest)
+  })
+})
+
+describe('ripemd160', () => {
+  test(`matches ${vectors.ripemd160.length} reference vectors`, () => {
+    for (const { digest, message } of vectors.ripemd160)
+      expect(engine.Hash.ripemd160(message)).toEqual(digest)
+  })
+
+  test('matches the million-`a` reference vector', () => {
+    const { digest, message } = vectors.ripemd160MillionA
+    expect(engine.Hash.ripemd160(message)).toEqual(digest)
+  })
+})
+
+describe('keccak256', () => {
+  test(`matches ${vectors.keccak256.length} OpenSSL vectors`, () => {
+    for (const { digest, message } of vectors.keccak256)
+      expect(engine.Hash.keccak256(message)).toEqual(digest)
+  })
+})
+
+describe('keccak_f1600', () => {
+  type Exports = { keccak_f1600(state: number): void }
+
+  /** Writes 25 lanes as little-endian 64-bit words, permutes, and reads back. */
+  async function permute(lanes: readonly bigint[]) {
+    // A separate instance, because this export is not part of the engine and so
+    // is deliberately not reachable through `WasmHash.load`.
+    const module = await instantiate<Exports>(wasmBase64)
+    module.reserve(200)
+    const view = module.view()
+    for (let lane = 0; lane < 25; lane++) {
+      let value = lanes[lane]!
+      for (let byte = 0; byte < 8; byte++) {
+        view[module.heapBase + lane * 8 + byte] = Number(value & 0xffn)
+        value >>= 8n
+      }
+    }
+
+    module.exports.keccak_f1600(module.heapBase)
+
+    const after = module.view()
+    const result: bigint[] = []
+    for (let lane = 0; lane < 25; lane++) {
+      let value = 0n
+      for (let byte = 7; byte >= 0; byte--)
+        value =
+          (value << 8n) | BigInt(after[module.heapBase + lane * 8 + byte]!)
+      result.push(value)
+    }
+    return result
+  }
+
+  test('matches the Keccak team‘s reference examples', async () => {
+    for (const example of vectors.keccakPermutation.examples)
+      expect(await permute(example.input)).toEqual(example.output)
+  })
+
+  test('reference examples chain, so the second is not a restatement', () => {
+    // XKCP's second example feeds the first one's output back in. Asserting the
+    // link means a parser that silently read the same block twice would fail
+    // here rather than quietly halving the coverage above.
+    const [first, second] = vectors.keccakPermutation.examples
+    expect(second!.input).toEqual(first!.output)
+    expect(second!.output).not.toEqual(first!.output)
+  })
+
+  test('the parsed fixture is internally consistent', () => {
+    // Checks the fixture, not the implementation. Each `rounds[n]` is the state
+    // after round `n`'s iota step, and nothing exported reaches a single round,
+    // so per-round agreement is not observable from here -- the permutation
+    // itself is covered above, end to end against `input`/`output`. What this
+    // catches is a parser that mis-read the file and quietly weakened that.
+    const { examples, rhoOffsets, roundConstants } = vectors.keccakPermutation
+    expect(roundConstants).toHaveLength(24)
+    expect(rhoOffsets).toHaveLength(25)
+    for (const example of examples) {
+      expect(example.rounds).toHaveLength(24)
+      expect(example.rounds.at(-1)).toEqual(example.output)
+    }
+  })
+})

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

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs'
+import { expect, test } from 'vp/test'
+import { instantiate } from '../internal/instantiate.js'
+import { wasmBase64 } from './runtime.wasm.js'
+
+test('freestanding runtime preserves memmove and realloc semantics', async () => {
+  const module = await instantiate<{ run(): number }>(wasmBase64)
+  expect(module.exports.run()).toBe(0)
+})
+
+test('memmove compares flat-memory offsets rather than C object pointers', () => {
+  const source = readFileSync(
+    new URL('../../../wasm/src/ox_rt.c', import.meta.url),
+    'utf8',
+  )
+  const body = source.match(/void \*memmove\([\s\S]*?\n}\n\nvoid \*memset/)?.[0]
+
+  expect(body).toBeDefined()
+  expect(body).toContain('if ((size_t)d < (size_t)s)')
+  expect(body).not.toMatch(/if\s*\(\s*d\s*<\s*s\s*\)/)
+})

package/src/wasm/_test/runtime.wasm.ts

@@ -0,0 +1,11 @@
+// Generated by `pnpm wasm:build --target=runtime-test`. Do not edit.
+//
+// Compiled from wasm/test/ox_rt.c, wasm/src/ox_rt.c
+// with wasi-sdk 25.0 + binaryen 123.
+//
+// `pnpm wasm:check` rebuilds this file and fails if the bytes differ, so any
+// change to the C or to `wasm/targets.ts` must be followed by `pnpm wasm:build`.
+
+/** Base64-encoded WASM binary. */
+export const wasmBase64 =
+  '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'

package/src/wasm/index.ts

@@ -0,0 +1,47 @@
+/** @entrypointCategory WASM */
+
+/**
+ * WASM implementations of ox's hash primitives, compiled from C.
+ *
+ * Load it and hand the result to {@link ox#Engine.set}. WASM must be compiled
+ * asynchronously, so the `await` lives here -- every call afterwards is
+ * synchronous.
+ *
+ * :::note
+ * Performance varies by primitive, input size, runtime, and processor. Run
+ * `pnpm bench:engines` to compare the available implementations on your target
+ * machine.
+ * :::
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Hash } from 'ox'
+ * import { Engine } from 'ox/wasm'
+ *
+ * await Engine.load()
+ *
+ * Hash.keccak256('0xdeadbeef')
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Engine from './Engine.js'
+
+/**
+ * WASM implementations of Ox's supported hash primitives.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine, Hash } from 'ox'
+ * import * as WasmHash from 'ox/wasm/Hash'
+ *
+ * Engine.set(await WasmHash.create())
+ *
+ * Hash.keccak256('0xdeadbeef')
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Hash from './Hash.js'

package/src/wasm/internal/hash.ts

@@ -0,0 +1,50 @@
+import { hmacSha256ScratchSize } from './hashes.wasm.js'
+import type { Module } from './instantiate.js'
+
+/** WASM exports used by the HMAC-SHA256 loader. @internal */
+export type Exports = {
+  hmac_sha256(
+    key: number,
+    keyLength: number,
+    message: number,
+    messageLength: number,
+    out: number,
+    scratch: number,
+  ): void
+  zero(ptr: number, length: number): void
+}
+
+/** Calls HMAC-SHA256 and clears its complete linear-memory region. @internal */
+export function hmacSha256(
+  module: Module<Exports>,
+  key: Uint8Array,
+  message: Uint8Array,
+): Uint8Array {
+  const keyLength = key.length
+  const messageLength = message.length
+  const out = 32
+  const messagePtr = module.heapBase
+  const keyPtr = messagePtr + messageLength
+  const outPtr = keyPtr + keyLength
+  const scratchPtr = Math.ceil((outPtr + out) / 4) * 4
+  const end = scratchPtr + hmacSha256ScratchSize
+  module.reserve(end - messagePtr)
+  const view = module.view()
+  try {
+    view.set(message, messagePtr)
+    view.set(key, keyPtr)
+    module.exports.hmac_sha256(
+      keyPtr,
+      keyLength,
+      messagePtr,
+      messageLength,
+      outPtr,
+      scratchPtr,
+    )
+    return module.view().slice(outPtr, outPtr + out)
+  } finally {
+    // Clear every byte this call owns, including HMAC working state when
+    // copying, hashing, or copying the digest back out throws.
+    module.exports.zero(messagePtr, end - messagePtr)
+  }
+}

package/src/wasm/internal/hashes.wasm.ts

@@ -0,0 +1,14 @@
+// Generated by `pnpm wasm:build --target=hashes`. Do not edit.
+//
+// Compiled from wasm/src/hashes.c, wasm/src/ox_rt.c
+// with wasi-sdk 25.0 + binaryen 123.
+//
+// `pnpm wasm:check` rebuilds this file and fails if the bytes differ, so any
+// change to the C or to `wasm/targets.ts` must be followed by `pnpm wasm:build`.
+
+/** Base64-encoded WASM binary. */
+export const wasmBase64 =
+  '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'
+
+/** Constant shared with the module's C source. */
+export const hmacSha256ScratchSize = 608

package/src/wasm/internal/instantiate.ts

@@ -0,0 +1,135 @@
+import * as Errors from '../../core/Errors.js'
+
+/**
+ * Shared WASM instantiation and memory plumbing.
+ *
+ * @internal
+ */
+
+/** An instantiated WASM module, with helpers for moving bytes across. */
+export type Module<exports extends Record<string, unknown>> = {
+  /** The module's exported functions. */
+  exports: exports
+  /** Address of the first byte we may write to. */
+  heapBase: number
+  /**
+   * Grows linear memory so `bytes` are available above `heapBase`.
+   *
+   * @throws {@link MemoryError} when the runtime refuses to grow.
+   */
+  reserve(bytes: number): void
+  /**
+   * A view over the module's current memory.
+   *
+   * Must be called after {@link Module.reserve} and again after anything that
+   * could grow memory: `WebAssembly.Memory.grow` detaches the previous
+   * `ArrayBuffer`, which silently turns any retained view into a zero-length one.
+   */
+  view(): Uint8Array
+}
+
+const pageSize = 65_536
+
+function decode(base64: string): Uint8Array {
+  // `Uint8Array.fromBase64` where available, then Node/Bun, then browsers and
+  // edge runtimes.
+  const fromBase64 = (
+    Uint8Array as unknown as {
+      fromBase64?: ((value: string) => Uint8Array) | undefined
+    }
+  ).fromBase64
+  if (fromBase64) return fromBase64(base64)
+  if (typeof Buffer !== 'undefined')
+    return new Uint8Array(Buffer.from(base64, 'base64'))
+  const binary = atob(base64)
+  const bytes = new Uint8Array(binary.length)
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)
+  return bytes
+}
+
+/**
+ * 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>> {
+  const { instance } = await WebAssembly.instantiate(decode(base64), {})
+  const exports = instance.exports as {
+    heap_base(): number
+    memory: WebAssembly.Memory
+  } & exports
+
+  const { memory } = exports
+  const heapBase = exports.heap_base()
+
+  let cached = new Uint8Array(memory.buffer)
+
+  return {
+    exports,
+    heapBase,
+    reserve(bytes) {
+      const required = heapBase + bytes
+      if (memory.buffer.byteLength >= required) return
+      const pages = Math.ceil((required - memory.buffer.byteLength) / pageSize)
+      try {
+        memory.grow(pages)
+      } catch (cause) {
+        throw new MemoryError({ bytes: required, cause: cause as Error })
+      }
+      cached = new Uint8Array(memory.buffer)
+    },
+    view() {
+      // `grow` detaches the old buffer, so compare identity rather than trusting
+      // the cached view.
+      if (cached.buffer !== memory.buffer)
+        cached = new Uint8Array(memory.buffer)
+      return cached
+    },
+  }
+}
+
+/**
+ * Memoizes a loader so concurrent callers compile the module once.
+ *
+ * The promise is memoized rather than its result, so a second call made while
+ * the first is still compiling awaits the same compilation. A rejected attempt
+ * is discarded, so a later call can try again.
+ *
+ * @internal
+ */
+export function memoize<value>(
+  load: () => Promise<value>,
+): () => Promise<value> {
+  let cached: Promise<value> | undefined
+  return () => {
+    // Only success is memoized. Compilation can fail for reasons that pass --
+    // a runtime briefly out of memory, say -- and caching the rejection would
+    // make one bad moment permanent for the life of the process.
+    cached ??= load().catch((error) => {
+      cached = undefined
+      throw error
+    })
+    return cached
+  }
+}
+
+/** Thrown when a WASM module cannot grow its memory to the required size. */
+export class MemoryError extends Errors.BaseError<Error> {
+  override readonly name = 'Wasm.MemoryError'
+
+  constructor({ bytes, cause }: { bytes: number; cause: Error }) {
+    super('WASM memory could not be grown to the required size.', {
+      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.',
+      ],
+    })
+  }
+}

package/src/zod/tempo/_test/ZoneId.test.ts

@@ -11,7 +11,7 @@ describe('ZoneId', () => {
   })
 
   test('decodes and encodes chain ids', () => {
-    expect(z.decode(z_ZoneId.chainId, 4_217_000_006)).toMatchInlineSnapshot(`6`)
-    expect(z.encode(z_ZoneId.chainId, 6)).toMatchInlineSnapshot(`4217000006`)
+    expect(z.decode(z_ZoneId.chainId, 421_700_001)).toMatchInlineSnapshot(`1`)
+    expect(z.encode(z_ZoneId.chainId, 1)).toMatchInlineSnapshot(`421700001`)
   })
 })