ox 1.0.5 → 1.1.0

package/src/core/Bls.ts

@@ -4,6 +4,7 @@ import * as BlsPoint from './BlsPoint.js'
 import * as Bytes from './Bytes.js'
 import * as Errors from './Errors.js'
 import * as Hex from './Hex.js'
+import * as engine from './internal/bls.js'
 import type { OneOf } from './internal/types.js'
 
 /**
@@ -116,12 +117,11 @@ export function aggregate(
     return point
   })
 
-  const first = normalized[0]!
+  // A single point aggregates to itself. The engine is not consulted because
+  // there is no addition to perform, only the identity.
+  if (normalized.length === 1) return normalized[0]!
 
-  // Fast path: a single point aggregates to itself.
-  if (normalized.length === 1) return first
-
-  const isG1 = typeof first.x === 'string'
+  const isG1 = typeof normalized[0]!.x === 'string'
   for (let i = 1; i < normalized.length; i++) {
     if ((typeof normalized[i]!.x === 'string') !== isG1)
       throw new Errors.BaseError(
@@ -130,13 +130,13 @@ export function aggregate(
   }
 
   const groupName = isG1 ? 'G1' : 'G2'
-  const group = isG1 ? bls.G1 : bls.G2
-  let acc = group.Point.ZERO
-  for (let i = 0; i < normalized.length; i++) {
-    const p = normalized[i]!
-    acc = acc.add(BlsPoint.toNoblePoint(p as any, groupName) as any)
-  }
-  return BlsPoint.fromNoblePoint(acc, groupName) as BlsPoint.BlsPoint
+  const point = engine.aggregate(
+    normalized.map((point) =>
+      BlsPoint.toBytes(point as BlsPoint.G1 | BlsPoint.G2),
+    ),
+    groupName,
+  )
+  return BlsPoint.fromBytes(point, groupName) as BlsPoint.BlsPoint
 }
 
 export declare namespace aggregate {
@@ -349,14 +349,8 @@ export function getPublicKey<
 export function getPublicKey(options: getPublicKey.Options): unknown {
   const { as = 'Object', privateKey, size = 'short-key:long-sig' } = options
   const groupName = size === 'short-key:long-sig' ? 'G1' : 'G2'
-  const group = groupName === 'G1' ? bls.G1 : bls.G2
-  const point = group.Point.BASE.multiply(
-    group.Point.Fn.fromBytes(Bytes.from(privateKey)),
-  )
-  const publicKey = BlsPoint.fromNoblePoint(
-    point,
-    groupName,
-  ) as BlsPoint.BlsPoint
+  const point = engine.getPublicKey(Bytes.from(privateKey), groupName)
+  const publicKey = BlsPoint.fromBytes(point, groupName) as BlsPoint.BlsPoint
   return formatBlsPoint(publicKey, as)
 }
 
@@ -422,7 +416,7 @@ export function randomPrivateKey<as extends 'Hex' | 'Bytes' = 'Hex'>(
   options: randomPrivateKey.Options<as> = {},
 ): randomPrivateKey.ReturnType<as> {
   const { as = 'Hex' } = options
-  const bytes = bls.utils.randomSecretKey()
+  const bytes = engine.randomSecretKey()
   if (as === 'Hex') return Hex.fromBytes(bytes) as never
   return bytes as never
 }
@@ -507,18 +501,11 @@ export function sign(options: sign.Options): unknown {
 
   const signatureGroupName: 'G1' | 'G2' =
     size === 'short-key:long-sig' ? 'G2' : 'G1'
-  const payloadGroup = signatureGroupName === 'G2' ? bls.G2 : bls.G1
-  const payloadPoint = payloadGroup.hashToCurve(
-    Bytes.from(payload),
-    suite ? { DST: Bytes.fromString(suite) } : undefined,
-  )
-
-  const privateKeyGroup = size === 'short-key:long-sig' ? bls.G1 : bls.G2
-  const signature = payloadPoint.multiply(
-    privateKeyGroup.Point.Fn.fromBytes(Bytes.from(privateKey)),
-  )
-
-  const result = BlsPoint.fromNoblePoint(
+  const signature = engine.sign(Bytes.from(payload), Bytes.from(privateKey), {
+    dst: suite ? Bytes.fromString(suite) : undefined,
+    group: signatureGroupName,
+  })
+  const result = BlsPoint.fromBytes(
     signature,
     signatureGroupName,
   ) as BlsPoint.BlsPoint
@@ -674,51 +661,14 @@ export function verify(options: verify.Options): boolean {
       : normalizeBlsPoint(publicKeyRaw as Hex.Hex | Bytes.Bytes, publicKeyGroup)
   ) as BlsPoint.BlsPoint<any>
 
-  const isShortSig = signatureGroup === 'G1'
-
-  const group = isShortSig ? bls.G1 : bls.G2
-  const payloadPoint = group.hashToCurve(
+  return engine.verify(
+    BlsPoint.toBytes(signature as BlsPoint.G1 | BlsPoint.G2),
     Bytes.from(payload),
-    suite ? { DST: Bytes.fromString(suite) } : undefined,
-  )
-
-  const shortSigPairing = () =>
-    bls.pairingBatch([
-      {
-        g1: payloadPoint as InstanceType<typeof bls.G1.Point>,
-        g2: BlsPoint.toNoblePoint(publicKey as any, 'G2') as InstanceType<
-          typeof bls.G2.Point
-        >,
-      },
-      {
-        g1: BlsPoint.toNoblePoint(signature as any, 'G1') as InstanceType<
-          typeof bls.G1.Point
-        >,
-        g2: bls.G2.Point.BASE.negate(),
-      },
-    ])
-
-  const longSigPairing = () =>
-    bls.pairingBatch([
-      {
-        g1: (
-          BlsPoint.toNoblePoint(publicKey as any, 'G1') as InstanceType<
-            typeof bls.G1.Point
-          >
-        ).negate(),
-        g2: payloadPoint as InstanceType<typeof bls.G2.Point>,
-      },
-      {
-        g1: bls.G1.Point.BASE,
-        g2: BlsPoint.toNoblePoint(signature as any, 'G2') as InstanceType<
-          typeof bls.G2.Point
-        >,
-      },
-    ])
-
-  return bls.fields.Fp12.eql(
-    isShortSig ? shortSigPairing() : longSigPairing(),
-    bls.fields.Fp12.ONE,
+    BlsPoint.toBytes(publicKey as BlsPoint.G1 | BlsPoint.G2),
+    {
+      dst: suite ? Bytes.fromString(suite) : undefined,
+      signatureGroup,
+    },
   )
 }
 

package/src/core/Ed25519.ts

@@ -2,6 +2,7 @@ import { ed25519 } 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/ed25519.js'
 
 /** Re-export of noble/curves Ed25519 utilities. */
 export const noble = ed25519
@@ -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 = ed25519.getPublicKey(privateKeyBytes)
+  const publicKeyBytes = engine.getPublicKey(privateKeyBytes)
   if (as === 'Hex') return Hex.fromBytes(publicKeyBytes) as never
   return publicKeyBytes as never
 }
@@ -122,7 +123,7 @@ export function randomPrivateKey<as extends 'Hex' | 'Bytes' = 'Hex'>(
   options: randomPrivateKey.Options<as> = {},
 ): randomPrivateKey.ReturnType<as> {
   const { as = 'Hex' } = options
-  const bytes = ed25519.utils.randomSecretKey()
+  const bytes = engine.randomSecretKey()
   if (as === 'Hex') return Hex.fromBytes(bytes) as never
   return bytes as never
 }
@@ -166,7 +167,7 @@ export function sign<as extends 'Hex' | 'Bytes' = 'Hex'>(
   const { as = 'Hex', payload, privateKey } = options
   const payloadBytes = Bytes.from(payload)
   const privateKeyBytes = Bytes.from(privateKey)
-  const signatureBytes = ed25519.sign(payloadBytes, privateKeyBytes)
+  const signatureBytes = engine.sign(payloadBytes, privateKeyBytes)
   if (as === 'Hex') return Hex.fromBytes(signatureBytes) as never
   return signatureBytes as never
 }
@@ -227,7 +228,7 @@ export function verify(options: verify.Options): boolean {
   const payloadBytes = Bytes.from(payload)
   const publicKeyBytes = Bytes.from(publicKey)
   const signatureBytes = Bytes.from(signature)
-  return ed25519.verify(signatureBytes, payloadBytes, publicKeyBytes)
+  return engine.verify(signatureBytes, payloadBytes, publicKeyBytes)
 }
 
 export declare namespace verify {
@@ -268,7 +269,7 @@ export function toX25519PublicKey<as extends 'Hex' | 'Bytes' = 'Hex'>(
 ): toX25519PublicKey.ReturnType<as> {
   const { as = 'Hex', publicKey } = options
   const publicKeyBytes = Bytes.from(publicKey)
-  const x25519PublicKeyBytes = ed25519.utils.toMontgomery(publicKeyBytes)
+  const x25519PublicKeyBytes = engine.toMontgomery(publicKeyBytes)
   if (as === 'Hex') return Hex.fromBytes(x25519PublicKeyBytes) as never
   return x25519PublicKeyBytes as never
 }
@@ -319,8 +320,7 @@ export function toX25519PrivateKey<as extends 'Hex' | 'Bytes' = 'Hex'>(
 ): toX25519PrivateKey.ReturnType<as> {
   const { as = 'Hex', privateKey } = options
   const privateKeyBytes = Bytes.from(privateKey)
-  const x25519PrivateKeyBytes =
-    ed25519.utils.toMontgomerySecret(privateKeyBytes)
+  const x25519PrivateKeyBytes = engine.toMontgomerySecret(privateKeyBytes)
   if (as === 'Hex') return Hex.fromBytes(x25519PrivateKeyBytes) as never
   return x25519PrivateKeyBytes as never
 }

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
 }