ox 1.0.4 → 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/ZoneId.test-d.ts

@@ -0,0 +1,16 @@
+import { expectTypeOf, test } from 'vp/test'
+import * as ZoneId from './ZoneId.js'
+
+test('accepts supported source IDs', () => {
+  expectTypeOf(ZoneId.fromChainId(421_700_001)).toEqualTypeOf<number>()
+  expectTypeOf(
+    ZoneId.fromChainId(1_424_310_001, 42_431),
+  ).toEqualTypeOf<number>()
+  expectTypeOf(ZoneId.toChainId(1)).toEqualTypeOf<number>()
+  expectTypeOf(ZoneId.toChainId(1, 42_431)).toEqualTypeOf<number>()
+
+  // @ts-expect-error Unsupported source ID.
+  ZoneId.fromChainId(421_700_001, 1)
+  // @ts-expect-error Unsupported source ID.
+  ZoneId.toChainId(1, 1)
+})

package/src/tempo/ZoneId.test.ts

@@ -3,40 +3,75 @@ import * as ZoneId from './ZoneId.js'
 
 describe('fromChainId', () => {
   test('default', () => {
-    expect(ZoneId.fromChainId(4_217_000_006)).toBe(6)
+    expect(ZoneId.chainIdBase).toMatchInlineSnapshot(`421700000`)
+    expect(ZoneId.fromChainId(421_700_001)).toMatchInlineSnapshot(`1`)
   })
 
-  test('zone 1', () => {
-    expect(ZoneId.fromChainId(4_217_000_001)).toBe(1)
+  test('Moderato', () => {
+    expect(ZoneId.fromChainId(1_424_310_028, 42_431)).toMatchInlineSnapshot(
+      `28`,
+    )
   })
 
-  test('zone 28', () => {
-    expect(ZoneId.fromChainId(4_217_000_028)).toBe(28)
+  test('unsupported source id', () => {
+    expect(() =>
+      // @ts-expect-error Unsupported source ID.
+      ZoneId.fromChainId(421_700_001, 1),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [ZoneId.UnsupportedSourceIdError: Source chain ID "1" is not supported.
+
+      Supported source chain IDs: 4217, 42431.]
+    `)
   })
 })
 
 describe('toChainId', () => {
   test('default', () => {
-    expect(ZoneId.toChainId(6)).toBe(4_217_000_006)
+    expect(ZoneId.toChainId(1)).toMatchInlineSnapshot(`421700001`)
+  })
+
+  test('Moderato', () => {
+    expect(ZoneId.toChainId(28, 42_431)).toMatchInlineSnapshot(`1424310028`)
   })
 
-  test('zone 1', () => {
-    expect(ZoneId.toChainId(1)).toBe(4_217_000_001)
+  test('wraps within the source chain range', () => {
+    expect(ZoneId.toChainId(1_002_610_001)).toMatchInlineSnapshot(`421700001`)
+    expect(ZoneId.toChainId(723_173_649, 42_431)).toMatchInlineSnapshot(
+      `1424310001`,
+    )
   })
 
-  test('zone 28', () => {
-    expect(ZoneId.toChainId(28)).toBe(4_217_000_028)
+  test('unsupported source id', () => {
+    expect(() =>
+      // @ts-expect-error Unsupported source ID.
+      ZoneId.toChainId(1, 1),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [ZoneId.UnsupportedSourceIdError: Source chain ID "1" is not supported.
+
+      Supported source chain IDs: 4217, 42431.]
+    `)
   })
 })
 
 describe('roundtrip', () => {
   test('fromChainId → toChainId', () => {
-    const chainId = 4_217_000_006
-    expect(ZoneId.toChainId(ZoneId.fromChainId(chainId))).toBe(chainId)
+    const chainId = 421_700_006
+    expect(ZoneId.toChainId(ZoneId.fromChainId(chainId))).toMatchInlineSnapshot(
+      `421700006`,
+    )
   })
 
   test('toChainId → fromChainId', () => {
     const zoneId = 42
-    expect(ZoneId.fromChainId(ZoneId.toChainId(zoneId))).toBe(zoneId)
+    expect(ZoneId.fromChainId(ZoneId.toChainId(zoneId))).toMatchInlineSnapshot(
+      `42`,
+    )
+  })
+
+  test('Moderato', () => {
+    const zoneId = 42
+    const sourceId = 42_431
+    const chainId = ZoneId.toChainId(zoneId, sourceId)
+    expect(ZoneId.fromChainId(chainId, sourceId)).toMatchInlineSnapshot(`42`)
   })
 })

package/src/tempo/ZoneId.ts

@@ -1,58 +1,94 @@
-import type * as Errors from '../core/Errors.js'
+import * as Errors from '../core/Errors.js'
+
+const chainIdConfig = {
+  4_217: {
+    base: 421_700_000,
+    range: 1_002_610_000,
+  },
+  42_431: {
+    base: 1_424_310_000,
+    range: 723_173_648,
+  },
+} as const
+
+const defaultSourceId = 4_217
 
 /**
- * Base offset for deriving zone chain IDs.
- *
- * Zone chain IDs are computed as `chainIdBase + zoneId`.
+ * Base offset for deriving Presto zone chain IDs.
  */
-export const chainIdBase = 4_217_000_000 as const
+export const chainIdBase = chainIdConfig[defaultSourceId].base
+
+/** Tempo source chain ID. */
+export type SourceId = keyof typeof chainIdConfig
 
 /**
  * Derives a zone ID from a zone chain ID.
  *
- * Zone chain IDs follow the formula `4_217_000_000 + zoneId`, so a chain ID
- * of `4217000006` corresponds to zone ID `6`.
+ * Zone chain IDs use the base assigned to their Tempo source chain.
  *
  * @example
  * ```ts twoslash
  * import { ZoneId } from 'ox/tempo'
  *
- * const zoneId = ZoneId.fromChainId(4_217_000_006)
- * // @log: 6
+ * const zoneId = ZoneId.fromChainId(421_700_001)
+ * // @log: 1
  * ```
  *
  * @param chainId - The zone chain ID.
+ * @param sourceId - The Tempo source chain ID. Defaults to `4217` (Presto).
  * @returns The zone ID.
  */
-export function fromChainId(chainId: number): number {
-  return chainId - chainIdBase
+export function fromChainId(
+  chainId: number,
+  sourceId: SourceId = defaultSourceId,
+): number {
+  return chainId - getChainIdConfig(sourceId).base
 }
 
 export declare namespace fromChainId {
-  type ErrorType = Errors.GlobalErrorType
+  type ErrorType = typeof UnsupportedSourceIdError | Errors.GlobalErrorType
 }
 
 /**
  * Derives a zone chain ID from a zone ID.
  *
- * Zone chain IDs follow the formula `4_217_000_000 + zoneId`, so zone ID
- * `6` corresponds to chain ID `4217000006`.
+ * Zone chain IDs use the base and range assigned to their Tempo source chain.
  *
  * @example
  * ```ts twoslash
  * import { ZoneId } from 'ox/tempo'
  *
- * const chainId = ZoneId.toChainId(6)
- * // @log: 4217000006
+ * const chainId = ZoneId.toChainId(1)
+ * // @log: 421700001
  * ```
  *
  * @param zoneId - The zone ID.
+ * @param sourceId - The Tempo source chain ID. Defaults to `4217` (Presto).
  * @returns The zone chain ID.
  */
-export function toChainId(zoneId: number): number {
-  return chainIdBase + zoneId
+export function toChainId(
+  zoneId: number,
+  sourceId: SourceId = defaultSourceId,
+): number {
+  const { base, range } = getChainIdConfig(sourceId)
+  return base + (zoneId % range)
 }
 
 export declare namespace toChainId {
-  type ErrorType = Errors.GlobalErrorType
+  type ErrorType = typeof UnsupportedSourceIdError | Errors.GlobalErrorType
+}
+
+/** Thrown when a Tempo source chain ID is unsupported. */
+export class UnsupportedSourceIdError extends Errors.BaseError {
+  override readonly name = 'ZoneId.UnsupportedSourceIdError'
+  constructor({ sourceId }: { sourceId: number }) {
+    super(`Source chain ID "${sourceId}" is not supported.`, {
+      metaMessages: ['Supported source chain IDs: 4217, 42431.'],
+    })
+  }
+}
+
+function getChainIdConfig(sourceId: number) {
+  if (sourceId === 4_217 || sourceId === 42_431) return chainIdConfig[sourceId]
+  throw new UnsupportedSourceIdError({ sourceId })
 }

package/src/tempo/index.ts

@@ -532,18 +532,17 @@ export * as VirtualMaster from './VirtualMaster.js'
 /**
  * Zone ID utilities for converting between zone IDs and zone chain IDs.
  *
- * Zone chain IDs are deterministically derived from zone IDs using the formula
- * `421_700_000 + zoneId`. This module provides helpers to convert between them.
+ * Zone chain IDs use the base and range assigned to their Tempo source chain.
  *
  * @example
  * ```ts twoslash
  * import { ZoneId } from 'ox/tempo'
  *
- * const zoneId = ZoneId.fromChainId(421_700_026)
- * // @log: 26
+ * const zoneId = ZoneId.fromChainId(421_700_001)
+ * // @log: 1
  *
- * const chainId = ZoneId.toChainId(26)
- * // @log: 421700026
+ * const chainId = ZoneId.toChainId(1)
+ * // @log: 421700001
  * ```
  *
  * @category Reference

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.4'
+export const version = '1.1.0'