ox 1.0.5 → 1.1.0

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

@@ -0,0 +1,102 @@
+import { Hash as CoreHash, Hex } from 'ox'
+import { Hash } from 'ox/node'
+import { describe, expect, test } from 'vp/test'
+
+describe('create', () => {
+  test('behavior: exposes the supported primitives', async () => {
+    const engine = await Hash.create()
+
+    expect(Object.keys(engine.Hash).sort()).toMatchInlineSnapshot(`
+      [
+        "hmacSha256",
+        "ripemd160",
+        "sha256",
+      ]
+    `)
+  })
+
+  test('behavior: matches published empty-input vectors', async () => {
+    const { hmacSha256, ripemd160, sha256 } = (await Hash.create()).Hash
+    const empty = new Uint8Array()
+
+    expect(Hex.fromBytes(sha256(empty))).toMatchInlineSnapshot(
+      `"0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"`,
+    )
+    expect(Hex.fromBytes(ripemd160(empty))).toMatchInlineSnapshot(
+      `"0x9c1185a5c5e9fc54612808977ee8f548b2258d31"`,
+    )
+    expect(Hex.fromBytes(hmacSha256(empty, empty))).toMatchInlineSnapshot(
+      `"0xb613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad"`,
+    )
+  })
+
+  test('behavior: agrees with the default across block boundaries', async () => {
+    const node = (await Hash.create()).Hash
+
+    for (const size of [0, 1, 55, 56, 63, 64, 65, 127, 128, 129]) {
+      const input = Uint8Array.from({ length: size }, (_, index) => index % 251)
+      expect(node.sha256(input)).toEqual(
+        CoreHash.sha256(input, { as: 'Bytes' }),
+      )
+      expect(node.ripemd160(input)).toEqual(
+        CoreHash.ripemd160(input, { as: 'Bytes' }),
+      )
+    }
+  })
+
+  test('behavior: agrees with the default across HMAC key sizes', async () => {
+    const { hmacSha256 } = (await Hash.create()).Hash
+    const message = Uint8Array.from({ length: 65 }, (_, index) => index % 251)
+
+    for (const size of [0, 1, 32, 63, 64, 65, 200]) {
+      const key = Uint8Array.from({ length: size }, (_, index) => index % 239)
+      expect(hmacSha256(key, message)).toEqual(
+        CoreHash.hmac256(key, message, { as: 'Bytes' }),
+      )
+    }
+  })
+
+  test('behavior: respects typed-array offsets', async () => {
+    const node = (await Hash.create()).Hash
+    const input = Uint8Array.from(
+      { length: 80 },
+      (_, index) => (index * 17) % 251,
+    ).subarray(7, 71)
+    const key = Uint8Array.from(
+      { length: 48 },
+      (_, index) => (index * 29) % 239,
+    ).subarray(5, 37)
+
+    expect(node.sha256(input)).toEqual(CoreHash.sha256(input, { as: 'Bytes' }))
+    expect(node.ripemd160(input)).toEqual(
+      CoreHash.ripemd160(input, { as: 'Bytes' }),
+    )
+    expect(node.hmacSha256(key, input)).toEqual(
+      CoreHash.hmac256(key, input, { as: 'Bytes' }),
+    )
+  })
+
+  test('behavior: returns a fresh engine', async () => {
+    const first = await Hash.create()
+    const second = await Hash.create()
+
+    expect(first === second).toMatchInlineSnapshot('false')
+    expect(first.Hash === second.Hash).toMatchInlineSnapshot('false')
+  })
+
+  test('behavior: returns owned Uint8Array values', async () => {
+    const { hmacSha256, ripemd160, sha256 } = (await Hash.create()).Hash
+    const input = Uint8Array.of(1, 2, 3)
+    const outputs = [hmacSha256(input, input), ripemd160(input), sha256(input)]
+
+    expect(outputs.map((output) => output.constructor === Uint8Array))
+      .toMatchInlineSnapshot(`
+      [
+        true,
+        true,
+        true,
+      ]
+    `)
+    expect(sha256(input) === sha256(input)).toMatchInlineSnapshot('false')
+  })
+})

package/src/node/index.ts

@@ -0,0 +1,40 @@
+/** @entrypointCategory Node */
+
+/**
+ * Node.js implementations of Ox's hash primitives, backed by `node:crypto`.
+ *
+ * Import this entrypoint only in Node.js. Its static `node:crypto` dependency
+ * is intentionally kept outside Ox's runtime-neutral entrypoint.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Hash } from 'ox'
+ * import { Engine } from 'ox/node'
+ *
+ * await Engine.load()
+ *
+ * Hash.sha256('0xdeadbeef')
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Engine from './Engine.js'
+
+/**
+ * Node.js implementations of Ox's supported hash primitives.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine, Hash } from 'ox'
+ * import * as NodeHash from 'ox/node/Hash'
+ *
+ * Engine.set(await NodeHash.create())
+ *
+ * Hash.sha256('0xdeadbeef')
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Hash from './Hash.js'

package/src/tempo/VirtualMaster.test.ts

@@ -1,5 +1,8 @@
+import { Bytes } from 'ox'
 import { VirtualMaster } from 'ox/tempo'
 import { describe, expect, test } from 'vp/test'
+import { instantiate } from '../wasm/internal/instantiate.js'
+import { wasmBase64 } from './internal/mine.wasm.js'
 
 const address = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266'
 const salt =
@@ -123,6 +126,32 @@ describe('mineSaltAsync', () => {
     `)
   })
 
+  // `workerCount` is `min(workers, ceil(count / chunkSize))`, so the cases
+  // above collapse to one worker and take the JavaScript fallback. Only a
+  // chunk size small enough to need two workers reaches the WASM, which is how
+  // a miner writing over its own Keccak constants went unnoticed.
+  test('agrees with the fallback once the WASM actually runs', async () => {
+    const viaFallback = await VirtualMaster.mineSaltAsync({
+      address,
+      count: 16,
+      start: 0xabf52ba0n,
+      workers: 1,
+    })
+
+    const viaWasm = await VirtualMaster.mineSaltAsync({
+      address,
+      chunkSize: 8,
+      count: 16,
+      start: 0xabf52ba0n,
+      workers: 2,
+    })
+
+    expect(viaWasm).toEqual(viaFallback)
+    expect(viaWasm?.salt).toMatchInlineSnapshot(
+      `"0x00000000000000000000000000000000000000000000000000000000abf52baf"`,
+    )
+  })
+
   test('finds the same salt with workers', async () => {
     const result = await VirtualMaster.mineSaltAsync({
       address,
@@ -150,6 +179,52 @@ describe('mineSaltAsync', () => {
     expect(result).toBeUndefined()
   })
 
+  test.each([
+    0,
+    -1,
+    1.5,
+    Number.NaN,
+    Number.POSITIVE_INFINITY,
+    2 ** 32,
+    Number.MAX_SAFE_INTEGER + 1,
+  ])('rejects chunk size %s outside the uint32 ABI', async (chunkSize) => {
+    await expect(
+      VirtualMaster.mineSaltAsync({
+        address,
+        chunkSize,
+        count: 1,
+        workers: 1,
+      }),
+    ).rejects.toThrow(
+      `Chunk size "${chunkSize}" is invalid. Expected a positive safe integer no greater than 4294967295.`,
+    )
+  })
+
+  test('accepts the maximum uint32 chunk size', async () => {
+    await expect(
+      VirtualMaster.mineSaltAsync({
+        address,
+        chunkSize: 2 ** 32 - 1,
+        count: 1,
+        start: 0n,
+        workers: 1,
+      }),
+    ).resolves.toBeUndefined()
+  })
+
+  test('treats the raw WASM count as unsigned', async () => {
+    type Exports = { mine(count: number): number }
+    const module = await instantiate<Exports>(wasmBase64)
+    module.reserve(84)
+    module.view().set(Bytes.fromHex(address), module.heapBase)
+    module.view().set(Bytes.fromHex(salt), module.heapBase + 20)
+
+    // 2 ** 31 has its sign bit set in the i32 passed by JavaScript. The first
+    // salt is already known to match, so unsigned C returns immediately; the old
+    // signed ABI interpreted the count as negative and skipped the loop.
+    expect(module.exports.mine(2 ** 31)).toBe(1)
+  })
+
   test('reports progress', async () => {
     const progressCalls: VirtualMaster.mineSaltAsync.Progress[] = []
 

package/src/tempo/VirtualMaster.ts

@@ -1,14 +1,15 @@
-import { keccak_256 } from '@noble/hashes/sha3.js'
 import * as Address from '../core/Address.js'
 import * as Bytes from '../core/Bytes.js'
 import * as Errors from '../core/Errors.js'
 import type * as Hash from '../core/Hash.js'
+import * as hash_ from '../core/internal/hash.js'
 import * as Hex from '../core/Hex.js'
 import * as VirtualMasterPool from './internal/virtualMasterPool.js'
 import * as VirtualAddress from './VirtualAddress.js'
 
 const tip20Prefix = '0x20c000000000000000000000'
 const zeroAddress = '0x0000000000000000000000000000000000000000'
+const maxUint32 = 2 ** 32 - 1
 
 /** A valid salt input for TIP-1022 master registration. */
 export type Salt = Hex.Hex | Bytes.Bytes | number | bigint
@@ -203,7 +204,7 @@ export function mineSalt(
   saltView.set(toFixedBytes(value.start ?? 0n, 32))
 
   for (let i = 0; i < count; i++) {
-    const hash = keccak_256(input)
+    const hash = hash_.keccak256(input)
 
     if (hash[0] === 0 && hash[1] === 0 && hash[2] === 0 && hash[3] === 0) {
       return {
@@ -289,13 +290,14 @@ export async function mineSaltAsync(
     workers = getDefaultWorkerCount(),
   } = parameters
 
-  const address = resolveAddress(parameters.address)
-  const start = toFixedHex(start_, 32)
-
+  assertChunkSize(chunkSize)
   assertCount(count)
   if (workers !== undefined) assertWorkers(workers)
   throwIfAborted(signal)
 
+  const address = resolveAddress(parameters.address)
+  const start = toFixedHex(start_, 32)
+
   const workerCount = Math.max(
     1,
     Math.min(workers, Math.ceil(count / chunkSize)),
@@ -341,6 +343,8 @@ export declare namespace mineSaltAsync {
     /**
      * Number of salts each worker processes before sending a progress update.
      *
+     * Must be a positive integer no greater than 2 ** 32 - 1.
+     *
      * @default 100_000
      */
     chunkSize?: number | undefined
@@ -576,6 +580,24 @@ function assertWorkers(workers: number) {
   )
 }
 
+/**
+ * Asserts that `chunkSize` fits the miner's unsigned 32-bit WASM ABI.
+ *
+ * @internal
+ */
+function assertChunkSize(chunkSize: number) {
+  if (
+    Number.isSafeInteger(chunkSize) &&
+    chunkSize > 0 &&
+    chunkSize <= maxUint32
+  )
+    return
+
+  throw new Errors.BaseError(
+    `Chunk size "${chunkSize}" is invalid. Expected a positive safe integer no greater than ${maxUint32}.`,
+  )
+}
+
 /**
  * Extracts or creates an error from an `AbortSignal`.
  *
@@ -679,7 +701,7 @@ function buildRegistrationDigest(
   const addressBytes = Bytes.fromHex(resolveAddress(address))
   buffer.set(addressBytes)
   buffer.set(toFixedBytes(salt, 32), addressBytes.length)
-  return keccak_256(buffer)
+  return hash_.keccak256(buffer)
 }
 
 /**

package/src/tempo/internal/mine.wasm.ts

@@ -1,17 +1,11 @@
-// Embedded TIP-1022 WASM keccak256 salt miner (compiled from mine.c).
+// Generated by `pnpm wasm:build --target=mine`. Do not edit.
 //
-// Memory layout at offset 1024:
-//   [0..19]   address   (20 bytes, set by JS)
-//   [20..51]  salt      (32 bytes, set/read by JS, incremented in-place)
-//   [52..83]  hash out  (32 bytes, written on match)
+// Compiled from wasm/src/mine.c, wasm/src/ox_rt.c
+// with wasi-sdk 25.0 + binaryen 123.
 //
-// Exported: mine(count: i32) -> i32 — returns 1 if found, 0 if not.
-//
-// Generated by: pnpm tsx scripts/build-mine-wasm.ts
+// `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 for the TIP-1022 salt miner. */
+/** Base64-encoded WASM binary. */
 export const wasmBase64 =
-  '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'
-
-/** Byte offset in WASM linear memory where mining I/O begins. */
-export const dataOffset = 1024
+  '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'

package/src/tempo/internal/virtualMasterPool.ts

@@ -185,7 +185,6 @@ main().catch(function(error) {
  */
 function getWorkerMineLoop(): string {
   return `
-var dataOffset = 1024
 
 function hexToBytes(hex) {
   var h = hex.startsWith('0x') ? hex.slice(2) : hex
@@ -218,6 +217,10 @@ function mineLoop(data, wasm, mem, postMessage) {
   var workerIndex = data.workerIndex
   var startBigInt = BigInt(data.start)
 
+  // Asked of the module rather than baked in: the buffer starts past the
+  // static data, wherever the linker put its end.
+  var dataOffset = wasm.heap_base()
+
   mem.set(addressBytes, dataOffset)
 
   for (

package/src/tsconfig.json

@@ -10,6 +10,7 @@
     "./**/*.bench.ts",
     "./**/*.bench-d.ts",
     "./**/*.snap-d.ts",
-    "./**/*.browser.test.ts"
+    "./**/*.browser.test.ts",
+    "./**/*.fuzz.ts"
   ]
 }

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.0.5'
+export const version = '1.1.0'

package/src/wasm/Engine.ts

@@ -0,0 +1,76 @@
+import * as CoreEngine from '../core/Engine.js'
+import type * as Errors from '../core/Errors.js'
+import * as Hash from './Hash.js'
+import type * as internal from './internal/instantiate.js'
+
+/**
+ * Compiles every implementation this entrypoint provides and installs it.
+ *
+ * WASM must be compiled asynchronously, so this is where the `await` lives.
+ * Everything afterwards, including the hashing itself, is synchronous.
+ *
+ * Call it once, during startup, before any crypto call. ox resolves the engine
+ * at call time, so values computed beforehand used whatever was installed then.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Hash } from 'ox'
+ * import { Engine } from 'ox/wasm'
+ *
+ * await Engine.load()
+ *
+ * Hash.keccak256('0xdeadbeef')
+ * ```
+ *
+ * @returns The engine that was installed.
+ */
+export async function load(): Promise<load.ReturnType> {
+  const engine = await create()
+  CoreEngine.set(engine)
+  return engine
+}
+
+export declare namespace load {
+  type ReturnType = create.ReturnType
+
+  type ErrorType =
+    | create.ErrorType
+    | CoreEngine.set.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/**
+ * Compiles every implementation this entrypoint provides, without installing
+ * it.
+ *
+ * Reach for this where an engine has to exist as a value: measuring one
+ * implementation against another, or installing through
+ * [`Engine.with`](/api/Engine/with) for the duration of a call. Combining
+ * engines does not need it, because
+ * [`Engine.set`](/api/Engine/set) merges -- `await load()` followed by
+ * `Engine.set({ Secp256k1 })` leaves both in place.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine, Hash } from 'ox'
+ * import { Engine as Wasm } from 'ox/wasm'
+ *
+ * const wasm = await Wasm.create()
+ *
+ * Engine.with(wasm, () => Hash.keccak256('0xdeadbeef'))
+ * ```
+ *
+ * @returns An engine, ready to install.
+ */
+export async function create(): Promise<create.ReturnType> {
+  return { ...(await Hash.create()) }
+}
+
+export declare namespace create {
+  /** Every slot this entrypoint supplies, each with its primitives present. */
+  type ReturnType = Hash.create.ReturnType
+
+  type ErrorType = internal.MemoryError | Errors.GlobalErrorType
+}

package/src/wasm/Hash.bench.ts

@@ -0,0 +1,60 @@
+import { hmac } from '@noble/hashes/hmac.js'
+import { ripemd160 as noble_ripemd160 } from '@noble/hashes/legacy.js'
+import { sha256 as noble_sha256 } from '@noble/hashes/sha2.js'
+import { keccak_256 as noble_keccak256 } from '@noble/hashes/sha3.js'
+import { bench, describe } from 'vp/test'
+import { create as createWasm } from './Hash.js'
+
+// Sizes expose fixed boundary overhead and sustained throughput. Crossovers
+// vary by primitive, runtime, and processor.
+//
+// Run `pnpm bench:engines` for the full engine comparison. Vitest cannot
+// run Rust, and this portable benchmark must remain browser-compatible.
+const sizes = [32, 64, 256, 1024, 4096, 65_536, 1_048_576] as const
+
+const wasm = (await createWasm()).Hash
+const key = Uint8Array.from({ length: 32 }, (_, index) => index % 97)
+
+for (const size of sizes) {
+  const bytes = Uint8Array.from({ length: size }, (_, index) => index % 251)
+
+  describe(`keccak256 (${size} bytes input)`, () => {
+    bench('ox', () => {
+      noble_keccak256(bytes)
+    })
+
+    bench('ox/wasm', () => {
+      wasm.keccak256(bytes)
+    })
+  })
+
+  describe(`sha256 (${size} bytes input)`, () => {
+    bench('ox', () => {
+      noble_sha256(bytes)
+    })
+
+    bench('ox/wasm', () => {
+      wasm.sha256(bytes)
+    })
+  })
+
+  describe(`ripemd160 (${size} bytes input)`, () => {
+    bench('ox', () => {
+      noble_ripemd160(bytes)
+    })
+
+    bench('ox/wasm', () => {
+      wasm.ripemd160(bytes)
+    })
+  })
+
+  describe(`hmacSha256 (${size} bytes input)`, () => {
+    bench('ox', () => {
+      hmac(noble_sha256, key, bytes)
+    })
+
+    bench('ox/wasm', () => {
+      wasm.hmacSha256(key, bytes)
+    })
+  })
+}

package/src/wasm/Hash.ts

@@ -0,0 +1,109 @@
+import type * as Engine from '../core/Engine.js'
+import type * as Errors from '../core/Errors.js'
+import * as hash from './internal/hash.js'
+import { wasmBase64 } from './internal/hashes.wasm.js'
+import * as internal from './internal/instantiate.js'
+
+export { MemoryError } from './internal/instantiate.js'
+
+type Exports = hash.Exports & {
+  keccak256(input: number, length: number, out: number): void
+  ripemd160(input: number, length: number, out: number): void
+  sha256(input: number, length: number, out: number): void
+}
+
+/** Digest sizes, in bytes. */
+const digestSize = { keccak256: 32, ripemd160: 20, sha256: 32 }
+
+/**
+ * Compilation is memoized; the engine object deliberately is not.
+ *
+ * Handing every caller the same object means one of them customising a slot
+ * for composition silently changes what a later `create` -- or `Engine.load`
+ * -- installs.
+ *
+ * @internal
+ */
+const instantiate = /*#__PURE__*/ internal.memoize(() =>
+  internal.instantiate<Exports>(wasmBase64),
+)
+
+/**
+ * Compiles the WASM implementation of the [`Hash`](/api/Hash) primitives, without
+ * installing it.
+ *
+ * Most callers want {@link ox#Engine.load} instead, which compiles every
+ * implementation this entrypoint provides and installs them in one call. Reach
+ * for this to take the `Hash` slot on its own, or to hold the implementation
+ * without touching the installed engine.
+ *
+ * :::note
+ * Performance varies by primitive, input size, runtime, and processor. Run
+ * `pnpm bench:engines` to compare Ox's default, Node, WASM, and Alloy
+ * implementations on your target machine.
+ * :::
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine, Hash } from 'ox'
+ * import * as WasmHash from 'ox/wasm/Hash'
+ *
+ * Engine.set(await WasmHash.create())
+ *
+ * Hash.keccak256('0xdeadbeef')
+ * ```
+ *
+ * @returns An engine supplying the `Hash` slot.
+ */
+export async function create(): Promise<create.ReturnType> {
+  {
+    const module = await instantiate()
+
+    // Copies `input` in, runs `hash`, and copies the digest back out.
+    function call(
+      hash: 'keccak256' | 'ripemd160' | 'sha256',
+      input: Uint8Array,
+    ): Uint8Array {
+      const out = digestSize[hash]
+      module.reserve(input.length + out)
+      const inputPtr = module.heapBase
+      const outPtr = inputPtr + input.length
+      module.view().set(input, inputPtr)
+      module.exports[hash](inputPtr, input.length, outPtr)
+      // `slice`, not `subarray`: the result must not alias WASM memory, which the
+      // next call overwrites and a `grow` detaches entirely.
+      return module.view().slice(outPtr, outPtr + out)
+    }
+
+    return {
+      Hash: {
+        hmacSha256: (key, message) => hash.hmacSha256(module, key, message),
+        keccak256: (input) => call('keccak256', input),
+        ripemd160: (input) => call('ripemd160', input),
+        sha256: (input) => call('sha256', input),
+      },
+    }
+  }
+}
+
+export declare namespace create {
+  /**
+   * The `Hash` slot, carrying every primitive this module implements.
+   *
+   * {@link ox#Engine.Engine} is optional all the way down so that an engine can
+   * fill in as little as it likes. This one always fills the same four, and
+   * saying so is what spares callers a non-null assertion per primitive.
+   */
+  type ReturnType = {
+    Hash: {
+      [key in
+        | 'hmacSha256'
+        | 'keccak256'
+        | 'ripemd160'
+        | 'sha256']-?: NonNullable<Engine.Hash[key]>
+    }
+  }
+
+  type ErrorType = internal.MemoryError | Errors.GlobalErrorType
+}