ox 1.0.4 → 1.1.0

package/src/core/Engine.ts

@@ -0,0 +1,235 @@
+import * as Caches from './Caches.js'
+import * as Errors from './Errors.js'
+import * as engine from './internal/engine.js'
+
+export type {
+  Bls,
+  Ecdh,
+  Ecdsa,
+  Eddsa,
+  Engine,
+  Hash,
+  Keystore,
+  Mnemonic,
+} from './internal/engine.js'
+
+/**
+ * Installs crypto implementations, replacing the `@noble/*` implementations ox
+ * uses by default.
+ *
+ * Slots and their functions are optional. Omissions preserve earlier
+ * overrides, or use Ox's default when none exists. Calls merge, so a later
+ * engine can override one primitive.
+ *
+ * Call this once, during application startup, before any crypto call. ox
+ * resolves the engine at call time, so values computed beforehand used whatever
+ * implementation was installed then.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox/wasm'
+ *
+ * await Engine.load()
+ * ```
+ *
+ * @example
+ * ### Overriding a Single Primitive
+ *
+ * ```ts twoslash
+ * import { Engine, Hash } from 'ox'
+ *
+ * Engine.set({
+ *   Hash: { keccak256: () => new Uint8Array(32) }
+ * })
+ *
+ * Hash.keccak256('0xdeadbeef')
+ * // @log: '0x0000000000000000000000000000000000000000000000000000000000000000'
+ * ```
+ *
+ * @param value - Engine to install.
+ */
+export function set(value: engine.Engine): void {
+  for (const [slot, primitives] of Object.entries(value)) {
+    if (!(engine.slots as readonly string[]).includes(slot))
+      throw new UnknownSlotError(slot)
+    const known = engine.primitives[slot as keyof engine.Engine]
+    // `primitives` is undefined where the caller is clearing the slot.
+    for (const primitive of Object.keys(primitives ?? {}))
+      if (!(known as readonly string[]).includes(primitive))
+        throw new UnknownPrimitiveError(slot, primitive)
+  }
+  engine.merge(value)
+  Caches.clear()
+}
+
+export declare namespace set {
+  type ErrorType =
+    | UnknownSlotError
+    | UnknownPrimitiveError
+    | Errors.GlobalErrorType
+}
+
+/**
+ * Returns the installed engine.
+ *
+ * Only overrides are returned -- slots left on ox's defaults are absent, so an
+ * empty object means ox is entirely on its default implementations.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Engine } from 'ox'
+ *
+ * Engine.get()
+ * // @log: {}
+ * ```
+ *
+ * @returns The installed engine.
+ */
+export function get(): engine.Engine {
+  // Slots are copied too, not just the root: a shared slot lets a caller write
+  // `get().Hash!.keccak256 = …` straight into the live registry, changing what
+  // ox calls without going through `set` and so without clearing the caches
+  // derived from it.
+  const copy: Record<string, unknown> = {}
+  for (const [name, slot] of Object.entries(engine.overrides))
+    copy[name] = { ...slot }
+  return copy as engine.Engine
+}
+
+export declare namespace get {
+  type ErrorType = Errors.GlobalErrorType
+}
+
+/**
+ * Restores ox's default implementations.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Engine } from 'ox'
+ *
+ * Engine.reset('Hash')
+ * Engine.reset()
+ * ```
+ *
+ * @param slot - Slot to reset. Resets every slot when omitted.
+ */
+export function reset(slot?: keyof engine.Engine): void {
+  // Deleting an unknown key succeeds silently, so without this a misspelled
+  // slot reports nothing and leaves the override it was meant to remove
+  // installed.
+  if (slot !== undefined && !(engine.slots as readonly string[]).includes(slot))
+    throw new UnknownSlotError(slot)
+  engine.reset(slot)
+  Caches.clear()
+}
+
+export declare namespace reset {
+  type ErrorType = UnknownSlotError | Errors.GlobalErrorType
+}
+
+/**
+ * Runs a function with an engine installed, then restores the previous engine.
+ *
+ * Only safe for synchronous functions: the engine is process-wide for the
+ * duration of the call, so concurrent asynchronous work would observe it too.
+ * Passing a function that returns a promise throws
+ * {@link ox#Engine.AsyncScopeError}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Engine, Hash } from 'ox'
+ *
+ * const hash = Engine.with(
+ *   { Hash: { keccak256: () => new Uint8Array(32) } },
+ *   () => Hash.keccak256('0xdeadbeef')
+ * )
+ * // @log: '0x0000000000000000000000000000000000000000000000000000000000000000'
+ * ```
+ *
+ * @param value - Engine to install for the duration of the call.
+ * @param fn - Synchronous function to run.
+ * @returns The return value of `fn`.
+ */
+// Declared unexported and surfaced only through the alias below: exporting the
+// backing name too would put an undocumented `Engine.with_` in the public
+// surface, which is then breaking to take away.
+function with_<returnType>(
+  value: engine.Engine,
+  fn: () => returnType,
+): returnType {
+  const previous = get()
+  try {
+    set(value)
+    const result = fn()
+    const thenable = result as
+      | { then?: (ok: () => void, err: () => void) => void }
+      | undefined
+    if (typeof thenable?.then === 'function') {
+      // Settle the promise we are about to discard. Otherwise its rejection is
+      // never observed, and Node can take the process down over it after the
+      // caller has already handled the `AsyncScopeError` thrown here.
+      thenable.then(
+        () => {},
+        () => {},
+      )
+      throw new AsyncScopeError()
+    }
+    return result
+  } finally {
+    engine.reset()
+    engine.merge(previous)
+    Caches.clear()
+  }
+}
+
+export { with_ as with }
+
+declare namespace with_ {
+  type ErrorType =
+    | AsyncScopeError
+    | set.ErrorType
+    | get.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/** Thrown when an unrecognized engine slot is supplied. */
+export class UnknownSlotError extends Errors.BaseError {
+  override readonly name = 'Engine.UnknownSlotError'
+
+  constructor(slot: string) {
+    super(`\`${slot}\` is not a valid engine slot.`, {
+      metaMessages: [`Valid slots: ${engine.slots.join(', ')}`],
+    })
+  }
+}
+
+/** Thrown when a slot is given an unrecognized primitive name. */
+export class UnknownPrimitiveError extends Errors.BaseError {
+  override readonly name = 'Engine.UnknownPrimitiveError'
+
+  constructor(slot: string, primitive: string) {
+    // The class is public, so `slot` is not necessarily one the table knows;
+    // an error that throws while being constructed hides the real failure.
+    const known: readonly string[] | undefined =
+      engine.primitives[slot as keyof engine.Engine]
+    super(
+      `\`${primitive}\` is not a valid primitive for the \`${slot}\` slot.`,
+      known ? { metaMessages: [`Valid primitives: ${known.join(', ')}`] } : {},
+    )
+  }
+}
+
+/** Thrown when {@link ox#Engine.with} is given an asynchronous function. */
+export class AsyncScopeError extends Errors.BaseError {
+  override readonly name = 'Engine.AsyncScopeError'
+
+  constructor() {
+    super('`Engine.with` cannot be used with an asynchronous function.', {
+      metaMessages: [
+        'The engine is process-wide, so a scoped override cannot be held across an `await`.',
+        'Use `Engine.set` instead.',
+      ],
+    })
+  }
+}

package/src/core/Hash.ts

@@ -1,15 +1,12 @@
-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 * as Bytes from './Bytes.js'
 import type * as Errors from './Errors.js'
 import * as Hex from './Hex.js'
+import * as engine from './internal/hash.js'
 
 /**
  * Calculates the [Keccak256](https://en.wikipedia.org/wiki/SHA-3) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
  *
- * This function is a re-export of `keccak_256` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.
+ * Backed by `keccak_256` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library, unless another implementation is installed with {@link ox#Engine.set}.
  *
  * @example
  * ```ts twoslash
@@ -54,7 +51,7 @@ export function keccak256<
 ): keccak256.ReturnType<as> {
   const isBytes = value instanceof Uint8Array
   const { as = isBytes ? 'Bytes' : 'Hex' } = options
-  const bytes = noble_keccak256(isBytes ? value : Bytes.from(value))
+  const bytes = engine.keccak256(isBytes ? value : Bytes.from(value))
   if (as === 'Bytes') return bytes as never
   return Hex.fromBytes(bytes) as never
 }
@@ -78,7 +75,7 @@ export declare namespace keccak256 {
 /**
  * Calculates the [HMAC-SHA256](https://en.wikipedia.org/wiki/HMAC) of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
  *
- * This function is a re-export of `hmac` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.
+ * Backed by `hmac` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library, unless another implementation is installed with {@link ox#Engine.set}.
  *
  * @example
  * ```ts twoslash
@@ -119,7 +116,7 @@ export function hmac256<
   const { as = isBytes ? 'Bytes' : 'Hex' } = options
   const keyBytes = key instanceof Uint8Array ? key : Bytes.from(key)
   const valueBytes = isBytes ? value : Bytes.from(value)
-  const bytes = hmac(noble_sha256, keyBytes, valueBytes)
+  const bytes = engine.hmacSha256(keyBytes, valueBytes)
   if (as === 'Bytes') return bytes as never
   return Hex.fromBytes(bytes) as never
 }
@@ -143,7 +140,7 @@ export declare namespace hmac256 {
 /**
  * Calculates the [Ripemd160](https://en.wikipedia.org/wiki/RIPEMD) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
  *
- * This function is a re-export of `ripemd160` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.
+ * Backed by `ripemd160` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library, unless another implementation is installed with {@link ox#Engine.set}.
  *
  * @example
  * ```ts twoslash
@@ -168,7 +165,7 @@ export function ripemd160<
 ): ripemd160.ReturnType<as> {
   const isBytes = value instanceof Uint8Array
   const { as = isBytes ? 'Bytes' : 'Hex' } = options
-  const bytes = noble_ripemd160(isBytes ? value : Bytes.from(value))
+  const bytes = engine.ripemd160(isBytes ? value : Bytes.from(value))
   if (as === 'Bytes') return bytes as never
   return Hex.fromBytes(bytes) as never
 }
@@ -192,7 +189,7 @@ export declare namespace ripemd160 {
 /**
  * Calculates the [Sha256](https://en.wikipedia.org/wiki/SHA-256) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
  *
- * This function is a re-export of `sha256` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.
+ * Backed by `sha256` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library, unless another implementation is installed with {@link ox#Engine.set}.
  *
  * @example
  * ```ts twoslash
@@ -217,7 +214,7 @@ export function sha256<
 ): sha256.ReturnType<as> {
   const isBytes = value instanceof Uint8Array
   const { as = isBytes ? 'Bytes' : 'Hex' } = options
-  const bytes = noble_sha256(isBytes ? value : Bytes.from(value))
+  const bytes = engine.sha256(isBytes ? value : Bytes.from(value))
   if (as === 'Bytes') return bytes as never
   return Hex.fromBytes(bytes) as never
 }

package/src/core/Keystore.ts

@@ -1,15 +1,6 @@
-import { ctr } from '@noble/ciphers/aes.js'
-import {
-  pbkdf2 as pbkdf2_noble,
-  pbkdf2Async as pbkdf2Async_noble,
-} from '@noble/hashes/pbkdf2.js'
-import {
-  scrypt as scrypt_noble,
-  scryptAsync as scryptAsync_noble,
-} from '@noble/hashes/scrypt.js'
-import { sha256 } from '@noble/hashes/sha2.js'
 import * as Bytes from './Bytes.js'
 import type * as Errors from './Errors.js'
+import * as engine from './internal/keystore.js'
 import * as Hash from './Hash.js'
 import type * as Hex from './Hex.js'
 import type { OneOf } from './internal/types.js'
@@ -113,10 +104,11 @@ export function decrypt<as extends 'Hex' | 'Bytes' = 'Hex'>(
   if (!Bytes.isEqual(mac, Bytes.from(`0x${keystore.crypto.mac}`)))
     throw new Error('corrupt keystore')
 
-  const data = ctr(
+  const data = engine.aesCtrDecrypt(
     encKey,
     Bytes.from(`0x${keystore.crypto.cipherparams.iv}`),
-  ).decrypt(ciphertext)
+    ciphertext,
+  )
 
   if (as === 'Hex') return Bytes.toHex(data) as never
   return data as never
@@ -194,7 +186,7 @@ export function encrypt(
   const encKey = Bytes.slice(key_, 0, 16)
   const macKey = Bytes.slice(key_, 16, 32)
 
-  const ciphertext = ctr(encKey, iv).encrypt(value_)
+  const ciphertext = engine.aesCtrEncrypt(encKey, iv, value_)
   const mac = Hash.keccak256(Bytes.concat(macKey, ciphertext))
 
   return {
@@ -239,7 +231,10 @@ export function pbkdf2(options: pbkdf2.Options) {
 
   const salt = options.salt ? Bytes.from(options.salt) : Bytes.random(32)
   const key = Bytes.toHex(
-    pbkdf2_noble(sha256, password, salt, { c: iterations, dkLen: 32 }),
+    engine.pbkdf2Sha256(Bytes.fromString(password), salt, {
+      c: iterations,
+      dkLen: 32,
+    }),
   )
 
   return defineKey(() => key, {
@@ -288,7 +283,7 @@ export async function pbkdf2Async(options: pbkdf2.Options) {
 
   const salt = options.salt ? Bytes.from(options.salt) : Bytes.random(32)
   const key = Bytes.toHex(
-    await pbkdf2Async_noble(sha256, password, salt, {
+    await engine.pbkdf2Sha256Async(Bytes.fromString(password), salt, {
       c: iterations,
       dkLen: 32,
     }),
@@ -331,7 +326,7 @@ export function scrypt(options: scrypt.Options) {
 
   const salt = options.salt ? Bytes.from(options.salt) : Bytes.random(32)
   const key = Bytes.toHex(
-    scrypt_noble(password, salt, { N: n, dkLen: 32, r, p }),
+    engine.scrypt(Bytes.fromString(password), salt, { N: n, dkLen: 32, p, r }),
   )
 
   return defineKey(() => key, {
@@ -385,7 +380,12 @@ export async function scryptAsync(options: scrypt.Options) {
 
   const salt = options.salt ? Bytes.from(options.salt) : Bytes.random(32)
   const key = Bytes.toHex(
-    await scryptAsync_noble(password, salt, { N: n, dkLen: 32, r, p }),
+    await engine.scryptAsync(Bytes.fromString(password), salt, {
+      N: n,
+      dkLen: 32,
+      p,
+      r,
+    }),
   )
 
   return defineKey(() => key, {

package/src/core/Mnemonic.ts

@@ -1,12 +1,9 @@
-import {
-  generateMnemonic,
-  mnemonicToSeedSync,
-  validateMnemonic,
-} from '@scure/bip39'
+import { generateMnemonic, validateMnemonic } from '@scure/bip39'
 import * as Bytes from './Bytes.js'
 import type * as Errors from './Errors.js'
 import * as HdKey from './HdKey.js'
 import type * as Hex from './Hex.js'
+import * as engine from './internal/mnemonic.js'
 
 export { path } from './HdKey.js'
 
@@ -184,7 +181,7 @@ export function toSeed<as extends 'Bytes' | 'Hex' = 'Bytes'>(
   options: toSeed.Options<as> = {},
 ): toSeed.ReturnType<as> {
   const { passphrase } = options
-  const seed = mnemonicToSeedSync(mnemonic, passphrase)
+  const seed = engine.toSeed(mnemonic, passphrase)
   if (options.as === 'Hex') return Bytes.toHex(seed) as never
   return seed as never
 }

package/src/core/P256.ts

@@ -8,6 +8,7 @@ import {
   normalizePublicKey,
   normalizeSignature,
 } from './internal/cryptoIo.js'
+import * as engine from './internal/p256.js'
 import * as Entropy from './internal/entropy.js'
 import {
   fromRecoveredBytes,
@@ -85,7 +86,7 @@ export function getPublicKey<as extends 'Hex' | 'Bytes' | 'Object' = 'Object'>(
   options: getPublicKey.Options<as>,
 ): getPublicKey.ReturnType<as> {
   const { as = 'Object', privateKey } = options
-  const bytes = noble_p256.getPublicKey(Bytes.from(privateKey), false)
+  const bytes = engine.getPublicKey(Bytes.from(privateKey))
   const publicKey = PublicKey.fromBytes(bytes)
   return formatPublicKey(publicKey, as) as never
 }
@@ -134,10 +135,9 @@ export function getSharedSecret<as extends 'Hex' | 'Bytes' = 'Hex'>(
   options: getSharedSecret.Options<as>,
 ): getSharedSecret.ReturnType<as> {
   const { as = 'Hex', privateKey, publicKey } = options
-  const sharedSecret = noble_p256.getSharedSecret(
+  const sharedSecret = engine.getSharedSecret(
     Bytes.from(privateKey),
     PublicKey.toBytes(normalizePublicKey(publicKey)),
-    true, // compressed
   )
   if (as === 'Hex') return Hex.fromBytes(sharedSecret) as never
   return sharedSecret as never
@@ -190,7 +190,7 @@ export function randomPrivateKey<as extends 'Hex' | 'Bytes' = 'Hex'>(
   options: randomPrivateKey.Options<as> = {},
 ): randomPrivateKey.ReturnType<as> {
   const { as = 'Hex' } = options
-  const bytes = noble_p256.utils.randomSecretKey()
+  const bytes = engine.randomSecretKey()
   if (as === 'Hex') return Hex.fromBytes(bytes) as never
   return bytes as never
 }
@@ -238,11 +238,8 @@ export function recoverPublicKey<
 >(options: recoverPublicKey.Options<as>): recoverPublicKey.ReturnType<as> {
   const { as = 'Object', payload, signature } = options
   const sigBytes = toRecoveredBytes(normalizeSignature<true>(signature))
-  const point = noble_p256.Signature.fromBytes(
-    sigBytes,
-    'recovered',
-  ).recoverPublicKey(Bytes.from(payload))
-  const publicKey = PublicKey.fromBytes(point.toBytes(false))
+  const bytes = engine.recoverPublicKey(sigBytes, Bytes.from(payload))
+  const publicKey = PublicKey.fromBytes(bytes)
   return formatPublicKey(publicKey, as) as never
 }
 
@@ -302,19 +299,13 @@ export function sign<as extends 'Hex' | 'Bytes' | 'Object' = 'Object'>(
     payload,
     privateKey,
   } = options
-  const sigBytes = noble_p256.sign(
-    Bytes.from(payload),
-    Bytes.from(privateKey),
-    {
-      extraEntropy:
-        typeof extraEntropy === 'boolean'
-          ? extraEntropy
-          : Bytes.from(extraEntropy),
-      lowS: true,
-      prehash: hash === true,
-      format: 'recovered',
-    },
-  )
+  const sigBytes = engine.sign(Bytes.from(payload), Bytes.from(privateKey), {
+    extraEntropy:
+      typeof extraEntropy === 'boolean'
+        ? extraEntropy
+        : Bytes.from(extraEntropy),
+    prehash: hash === true,
+  })
   const signature = fromRecoveredBytes(sigBytes)
   return formatSignature(signature, as) as never
 }
@@ -381,11 +372,11 @@ export declare namespace sign {
  */
 export function verify(options: verify.Options): boolean {
   const { hash, payload, publicKey, signature } = options
-  return noble_p256.verify(
+  return engine.verify(
     toCompactBytes(normalizeSignature(signature)),
     Bytes.from(payload),
     PublicKey.toBytes(normalizePublicKey(publicKey)),
-    { lowS: true, prehash: hash === true },
+    { prehash: hash === true },
   )
 }
 

package/src/core/Rlp_tx.bench.ts

@@ -1,7 +1,5 @@
-// Track B / transactions: bench coverage for the RLP encode/decode hot
-// paths exercised by every TxEnvelope codec. The encoding thread owns
-// codec-only bench naming under `src/core/Rlp.bench.ts`; this file scopes
-// to transaction-shaped inputs to avoid collision.
+// Scoped to transaction-shaped inputs, the RLP paths every TxEnvelope codec
+// exercises. `src/core/Rlp.bench.ts` covers RLP on its own terms.
 
 import { bench, describe } from 'vp/test'
 import * as Hex from './Hex.js'

package/src/core/Secp256k1.ts

@@ -9,6 +9,7 @@ import {
   normalizePublicKey,
   normalizeSignature,
 } from './internal/cryptoIo.js'
+import * as engine from './internal/secp256k1.js'
 import * as Entropy from './internal/entropy.js'
 import {
   fromRecoveredBytes,
@@ -89,7 +90,7 @@ export function getPublicKey<as extends 'Hex' | 'Bytes' | 'Object' = 'Object'>(
   options: getPublicKey.Options<as>,
 ): getPublicKey.ReturnType<as> {
   const { as = 'Object', privateKey } = options
-  const bytes = secp256k1.getPublicKey(Bytes.from(privateKey), false)
+  const bytes = engine.getPublicKey(Bytes.from(privateKey))
   const publicKey = PublicKey.fromBytes(bytes)
   return formatPublicKey(publicKey, as) as never
 }
@@ -142,10 +143,9 @@ export function getSharedSecret<as extends 'Hex' | 'Bytes' = 'Hex'>(
   options: getSharedSecret.Options<as>,
 ): getSharedSecret.ReturnType<as> {
   const { as = 'Hex', privateKey, publicKey } = options
-  const sharedSecret = secp256k1.getSharedSecret(
+  const sharedSecret = engine.getSharedSecret(
     Bytes.from(privateKey),
     PublicKey.toBytes(normalizePublicKey(publicKey)),
-    true, // compressed
   )
   if (as === 'Hex') return Hex.fromBytes(sharedSecret) as never
   return sharedSecret as never
@@ -199,7 +199,7 @@ export function randomPrivateKey<as extends 'Hex' | 'Bytes' = 'Hex'>(
   options: randomPrivateKey.Options<as> = {},
 ): randomPrivateKey.ReturnType<as> {
   const { as = 'Hex' } = options
-  const bytes = secp256k1.utils.randomSecretKey()
+  const bytes = engine.randomSecretKey()
   if (as === 'Hex') return Hex.fromBytes(bytes) as never
   return bytes as never
 }
@@ -296,11 +296,8 @@ export function recoverPublicKey<
 >(options: recoverPublicKey.Options<as>): recoverPublicKey.ReturnType<as> {
   const { as = 'Object', payload, signature } = options
   const sigBytes = toRecoveredBytes(normalizeSignature<true>(signature))
-  const point = secp256k1.Signature.fromBytes(
-    sigBytes,
-    'recovered',
-  ).recoverPublicKey(Bytes.from(payload))
-  const publicKey = PublicKey.fromBytes(point.toBytes(false))
+  const bytes = engine.recoverPublicKey(sigBytes, Bytes.from(payload))
+  const publicKey = PublicKey.fromBytes(bytes)
   return formatPublicKey(publicKey, as) as never
 }
 
@@ -360,14 +357,12 @@ export function sign<as extends 'Hex' | 'Bytes' | 'Object' = 'Object'>(
     payload,
     privateKey,
   } = options
-  const sigBytes = secp256k1.sign(Bytes.from(payload), Bytes.from(privateKey), {
+  const sigBytes = engine.sign(Bytes.from(payload), Bytes.from(privateKey), {
     extraEntropy:
       typeof extraEntropy === 'boolean'
         ? extraEntropy
         : Bytes.from(extraEntropy),
-    lowS: true,
     prehash: hash === true,
-    format: 'recovered',
   })
   const signature = fromRecoveredBytes(sigBytes)
   return formatSignature(signature, as) as never
@@ -462,11 +457,11 @@ export function verify(options: verify.Options): boolean {
       recoverAddress({ payload, signature: options.signature }),
     )
   const sig = normalizeSignature(options.signature)
-  return secp256k1.verify(
+  return engine.verify(
     toCompactBytes(sig),
     Bytes.from(payload),
     PublicKey.toBytes(normalizePublicKey(options.publicKey)),
-    { lowS: true, prehash: hash === true },
+    { prehash: hash === true },
   )
 }
 

package/src/core/TxEnvelopeEip1559.bench.ts

@@ -1,8 +1,3 @@
-// Track B / transactions: bench coverage for the EIP-1559 envelope
-// serialize / deserialize / hash hot paths. Targets per
-// `tasks/perf-api-audit-transactions.md` Phase 1: ≥ 2× faster envelope
-// serialize and deserialize at the same input.
-
 import { bench, describe } from 'vp/test'
 import * as TxEnvelopeEip1559 from './TxEnvelopeEip1559.js'
 

package/src/core/WebCryptoP256.ts

@@ -1,4 +1,3 @@
-import { p256 } from '@noble/curves/nist.js'
 import * as Bytes from './Bytes.js'
 import * as Errors from './Errors.js'
 import * as Hex from './Hex.js'
@@ -7,12 +6,13 @@ import {
   normalizePublicKey,
   normalizeSignature,
 } from './internal/cryptoIo.js'
+import { p256N } from './internal/curves.js'
 import type { Compute } from './internal/types.js'
 import * as PublicKey from './PublicKey.js'
 import type * as Signature from './Signature.js'
 
 /** secp256r1 / P-256 curve order. */
-const N = p256.Point.CURVE().n
+const N = p256N
 
 /**
  * Generates an ECDSA P256 key pair that includes:

package/src/core/X25519.ts

@@ -2,6 +2,7 @@ import { x25519 } from '@noble/curves/ed25519.js'
 import * as Bytes from './Bytes.js'
 import type * as Errors from './Errors.js'
 import * as Hex from './Hex.js'
+import * as engine from './internal/x25519.js'
 
 /** Re-export of noble/curves X25519 utilities. */
 export const noble = x25519
@@ -77,7 +78,7 @@ export function getPublicKey<as extends 'Hex' | 'Bytes' = 'Hex'>(
 ): getPublicKey.ReturnType<as> {
   const { as = 'Hex', privateKey } = options
   const privateKeyBytes = Bytes.from(privateKey)
-  const publicKeyBytes = x25519.getPublicKey(privateKeyBytes)
+  const publicKeyBytes = engine.getPublicKey(privateKeyBytes)
   if (as === 'Hex') return Hex.fromBytes(publicKeyBytes) as never
   return publicKeyBytes as never
 }
@@ -130,7 +131,7 @@ export function getSharedSecret<as extends 'Hex' | 'Bytes' = 'Hex'>(
   const { as = 'Hex', privateKey, publicKey } = options
   const privateKeyBytes = Bytes.from(privateKey)
   const publicKeyBytes = Bytes.from(publicKey)
-  const sharedSecretBytes = x25519.getSharedSecret(
+  const sharedSecretBytes = engine.getSharedSecret(
     privateKeyBytes,
     publicKeyBytes,
   )
@@ -182,7 +183,7 @@ export function randomPrivateKey<as extends 'Hex' | 'Bytes' = 'Hex'>(
   options: randomPrivateKey.Options<as> = {},
 ): randomPrivateKey.ReturnType<as> {
   const { as = 'Hex' } = options
-  const bytes = x25519.utils.randomSecretKey()
+  const bytes = engine.randomSecretKey()
   if (as === 'Hex') return Hex.fromBytes(bytes) as never
   return bytes as never
 }

package/src/core/_test/AbiParameters.adversarial.fuzz.ts

@@ -3,8 +3,7 @@ import { AbiParameters, Bytes, Hex } from 'ox'
 import { describe, expect } from 'vp/test'
 
 import { arbitraryAbiCase } from '../../../test/fuzz/arbitraries/abi.js'
-
-const numRuns = Number(process.env.FC_NUM_RUNS) || 100
+import { numRuns } from '../../../test/fuzz/numRuns.js'
 
 /**
  * Whitelist of error names ox is allowed to throw on adversarial-but-