ox 1.0.5 → 1.1.2

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.2'

package/src/wasm/Ed25519.ts

@@ -0,0 +1,114 @@
+import type * as Engine from '../core/Engine.js'
+import type * as Errors from '../core/Errors.js'
+import * as crypto25519 from './internal/crypto25519.js'
+import * as ed25519 from './internal/ed25519.js'
+import * as internal from './internal/instantiate.js'
+
+export * from '../core/Ed25519.js'
+export { MemoryError } from './internal/instantiate.js'
+
+const keySize = 32
+const signatureSize = 64
+
+/**
+ * Compiles WASM implementations of selected [`Ed25519`](/api/Ed25519)
+ * primitives, without installing them.
+ *
+ * Public-key conversion and random key generation remain on Ox's default
+ * implementation. The public conversion is omitted because Monocypher does not
+ * reproduce Ox's invalid-point validation.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Ed25519 } from 'ox/wasm'
+ *
+ * await Engine.install({ Ed25519: Ed25519.engine() })
+ *
+ * Ed25519.getPublicKey({ privateKey: '0x...' })
+ * ```
+ *
+ * @returns The WASM implementation of part of the `Ed25519` slot.
+ */
+export async function engine(): Promise<engine.ReturnType> {
+  const module = await crypto25519.load()
+
+  return {
+    getPublicKey(privateKey) {
+      assertLength(privateKey, keySize, 'private key')
+      module.reserve(keySize * 2)
+      const privateKeyPtr = module.heapBase
+      const publicKeyPtr = privateKeyPtr + keySize
+      try {
+        module.view().set(privateKey, privateKeyPtr)
+        module.exports.ed25519_get_public_key(privateKeyPtr, publicKeyPtr)
+        return module.view().slice(publicKeyPtr, publicKeyPtr + keySize)
+      } finally {
+        module.exports.zero(privateKeyPtr, keySize * 2)
+      }
+    },
+    sign(payload, privateKey) {
+      assertLength(privateKey, keySize, 'private key')
+      return ed25519.sign(module, payload, privateKey)
+    },
+    toMontgomerySecret(privateKey) {
+      assertLength(privateKey, keySize, 'private key')
+      module.reserve(keySize * 2)
+      const privateKeyPtr = module.heapBase
+      const secretKeyPtr = privateKeyPtr + keySize
+      try {
+        module.view().set(privateKey, privateKeyPtr)
+        module.exports.ed25519_to_montgomery_secret(privateKeyPtr, secretKeyPtr)
+        return module.view().slice(secretKeyPtr, secretKeyPtr + keySize)
+      } finally {
+        module.exports.zero(privateKeyPtr, keySize * 2)
+      }
+    },
+    verify(signature, payload, publicKey) {
+      assertLength(signature, signatureSize, 'signature')
+      assertLength(publicKey, keySize, 'public key')
+      const size = signatureSize + payload.length + keySize
+      module.reserve(size)
+      const signaturePtr = module.heapBase
+      const payloadPtr = signaturePtr + signatureSize
+      const publicKeyPtr = payloadPtr + payload.length
+      try {
+        const memory = module.view()
+        memory.set(signature, signaturePtr)
+        memory.set(payload, payloadPtr)
+        memory.set(publicKey, publicKeyPtr)
+        return (
+          module.exports.ed25519_verify(
+            signaturePtr,
+            payloadPtr,
+            payload.length,
+            publicKeyPtr,
+          ) === 1
+        )
+      } finally {
+        module.exports.zero(signaturePtr, size)
+      }
+    },
+  }
+}
+
+export declare namespace engine {
+  /** Every `Ed25519` primitive this module implements. */
+  type ReturnType = {
+    [key in
+      | 'getPublicKey'
+      | 'sign'
+      | 'toMontgomerySecret'
+      | 'verify']-?: NonNullable<Engine.Eddsa[key]>
+  }
+
+  type ErrorType = internal.MemoryError | Errors.GlobalErrorType
+}
+
+function assertLength(value: Uint8Array, length: number, name: string): void {
+  if (value.length !== length)
+    throw new RangeError(
+      `Ed25519 ${name} must be ${length} bytes, got ${value.length}`,
+    )
+}

package/src/wasm/Engine.ts

@@ -0,0 +1,121 @@
+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 Mnemonic from './Mnemonic.js'
+import * as X25519 from './X25519.js'
+import type * as internal from './internal/instantiate.js'
+
+export {
+  AsyncScopeError,
+  get,
+  InvalidSlotValueError,
+  reset,
+  set,
+  UnknownPrimitiveError,
+  UnknownSlotError,
+  with,
+} from '../core/Engine.js'
+export type {
+  Bls,
+  Ecdh,
+  Ecdsa,
+  Eddsa,
+  Engine,
+  Hash,
+  Keystore,
+  Mnemonic,
+} from '../core/Engine.js'
+
+/**
+ * Compiles and installs every WASM implementation this entrypoint provides.
+ *
+ * Slot compilation starts concurrently. Nothing is installed until every slot
+ * resolves successfully.
+ *
+ * Call this 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 { Engine, Hash } from 'ox/wasm'
+ *
+ * await Engine.install()
+ *
+ * Hash.sha256('0xdeadbeef')
+ * ```
+ *
+ * @returns The engine that was installed.
+ */
+export async function install(): Promise<install.ReturnType> {
+  return CoreEngine.install({
+    Ed25519: Ed25519.engine(),
+    Hash: Hash.engine(),
+    Keystore: Keystore.engine(),
+    Mnemonic: Mnemonic.engine(),
+    X25519: X25519.engine(),
+  })
+}
+
+export declare namespace install {
+  type ReturnType = engine.ReturnType
+
+  type ErrorType =
+    | engine.ErrorType
+    | CoreEngine.install.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/**
+ * Compiles every WASM implementation this entrypoint provides, without
+ * installing it.
+ *
+ * Reach for this where an engine has to exist as a value, such as a benchmark
+ * or an [`Engine.with`](/api/Engine/with) scope. Use the individual module's
+ * `engine` function to select only some slots.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine, Hash } from 'ox'
+ * import { Engine as Wasm } from 'ox/wasm'
+ *
+ * const wasm = await Wasm.engine()
+ *
+ * Engine.with(wasm, () => Hash.sha256('0xdeadbeef'))
+ * ```
+ *
+ * @returns An engine, ready to install.
+ */
+export async function engine(): Promise<engine.ReturnType> {
+  const [ed25519, hash, keystore, mnemonic, x25519] = await Promise.all([
+    Ed25519.engine(),
+    Hash.engine(),
+    Keystore.engine(),
+    Mnemonic.engine(),
+    X25519.engine(),
+  ])
+  return {
+    Ed25519: ed25519,
+    Hash: hash,
+    Keystore: keystore,
+    Mnemonic: mnemonic,
+    X25519: x25519,
+  }
+}
+
+export declare namespace engine {
+  /** Every slot this entrypoint supplies, each with its primitives present. */
+  type ReturnType = {
+    Ed25519: Ed25519.engine.ReturnType
+    Hash: Hash.engine.ReturnType
+    Keystore: Keystore.engine.ReturnType
+    Mnemonic: Mnemonic.engine.ReturnType
+    X25519: X25519.engine.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 { engine as wasmEngine } 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 wasmEngine()
+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,88 @@
+import type * as Engine from '../core/Engine.js'
+import type * as Errors from '../core/Errors.js'
+import * as blake3 from './internal/blake3.js'
+import * as hash from './internal/hash.js'
+import * as hashes from './internal/hashes.js'
+import * as internal from './internal/instantiate.js'
+
+export * from '../core/Hash.js'
+export { MemoryError } from './internal/instantiate.js'
+
+/** Digest sizes, in bytes. */
+const digestSize = { keccak256: 32, ripemd160: 20, sha256: 32 }
+
+/**
+ * Compiles the WASM implementation of the [`Hash`](/api/Hash) primitives,
+ * without installing it.
+ *
+ * Most callers want
+ * [`Engine.install`](/wasm/crypto/Engine/install) 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 } from 'ox'
+ * import { Hash } from 'ox/wasm'
+ *
+ * await Engine.install({ Hash: Hash.engine() })
+ *
+ * Hash.keccak256('0xdeadbeef')
+ * ```
+ *
+ * @returns The WASM implementation of the `Hash` slot.
+ */
+export async function engine(): Promise<engine.ReturnType> {
+  {
+    const [blake3Module, module] = await Promise.all([
+      blake3.load(),
+      hashes.load(),
+    ])
+
+    // 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 {
+      blake3: (input) => blake3.hash(blake3Module, input),
+      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 engine {
+  /** Every `Hash` primitive this module implements. */
+  type ReturnType = {
+    [key in
+      | 'blake3'
+      | 'hmacSha256'
+      | 'keccak256'
+      | 'ripemd160'
+      | 'sha256']-?: NonNullable<Engine.Hash[key]>
+  }
+
+  type ErrorType = internal.MemoryError | Errors.GlobalErrorType
+}

package/src/wasm/Keystore.ts

@@ -0,0 +1,48 @@
+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'
+
+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.
+ *
+ * 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.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Keystore } from 'ox/wasm'
+ *
+ * await Engine.install({ Keystore: Keystore.engine() })
+ *
+ * Keystore.pbkdf2({ password: 'testpassword' })
+ * ```
+ *
+ * @returns The WASM implementation of synchronous PBKDF2-HMAC-SHA256.
+ */
+export async function engine(): Promise<engine.ReturnType> {
+  const module = await hashes.load()
+  return {
+    pbkdf2Sha256: (password, salt, options) =>
+      pbkdf2.pbkdf2Sha256(module, password, salt, options),
+  }
+}
+
+export declare namespace engine {
+  /** The WASM `Keystore` primitives this module implements. */
+  type ReturnType = {
+    pbkdf2Sha256: NonNullable<Engine.Keystore['pbkdf2Sha256']>
+  }
+
+  type ErrorType = internal.MemoryError | Errors.GlobalErrorType
+}