ox 1.1.0 → 1.1.2

package/src/node/Mnemonic.ts

@@ -0,0 +1,68 @@
+import * as crypto from 'node:crypto'
+import type * as Engine from '../core/Engine.js'
+import type * as Errors from '../core/Errors.js'
+
+export * from '../core/Mnemonic.js'
+
+/**
+ * Creates a Node.js implementation of the [`Mnemonic`](/api/Mnemonic) engine
+ * slot, without installing it.
+ *
+ * Most callers want [`Engine.install`](/node/crypto/Engine/install) instead,
+ * which installs every implementation this entrypoint provides. Reach for this
+ * to install or hold the `Mnemonic` slot on its own.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Mnemonic } from 'ox/node'
+ *
+ * await Engine.install({ Mnemonic: Mnemonic.engine() })
+ *
+ * Mnemonic.toSeed(
+ *   'test test test test test test test test test test test junk'
+ * )
+ * ```
+ *
+ * @returns The raw `Mnemonic` engine slot.
+ */
+export function engine(): Promise<engine.ReturnType> {
+  return Promise.resolve({
+    toSeed: (mnemonic, passphrase = '') => {
+      if (typeof mnemonic !== 'string')
+        throw new TypeError(`invalid mnemonic type: ${typeof mnemonic}`)
+
+      const normalized = mnemonic.normalize('NFKD')
+      if (![12, 15, 18, 21, 24].includes(normalized.split(' ').length))
+        throw new Error('Invalid mnemonic')
+
+      return copyAndClear(
+        crypto.pbkdf2Sync(
+          normalized,
+          `mnemonic${passphrase}`.normalize('NFKD'),
+          2048,
+          64,
+          'sha512',
+        ),
+      )
+    },
+  })
+}
+
+export declare namespace engine {
+  /** Every `Mnemonic` primitive this module implements. */
+  type ReturnType = {
+    [key in 'toSeed']-?: NonNullable<Engine.Mnemonic[key]>
+  }
+
+  type ErrorType = Errors.GlobalErrorType
+}
+
+function copyAndClear(value: Buffer): Uint8Array {
+  try {
+    return Uint8Array.from(value)
+  } finally {
+    value.fill(0)
+  }
+}

package/src/node/P256.ts

@@ -0,0 +1,48 @@
+import * as crypto from 'node:crypto'
+import type * as Engine from '../core/Engine.js'
+import type * as Errors from '../core/Errors.js'
+
+export * from '../core/P256.js'
+
+/**
+ * Creates a Node.js implementation of the [`P256`](/api/P256) engine slot,
+ * without installing it.
+ *
+ * Node's other P256 operations do not reproduce Ox's recovered-signature and
+ * compressed-shared-point contracts, so they remain on Ox's defaults.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { P256 } from 'ox/node'
+ *
+ * await Engine.install({ P256: P256.engine() })
+ *
+ * P256.getPublicKey({ privateKey: '0x...' })
+ * ```
+ *
+ * @returns The raw `P256` engine slot.
+ */
+export function engine(): Promise<engine.ReturnType> {
+  return Promise.resolve({
+    getPublicKey: (privateKey) => {
+      if (privateKey.length !== 32)
+        throw new RangeError(
+          `P256 private key must be 32 bytes, got ${privateKey.length}`,
+        )
+      const ecdh = crypto.createECDH('prime256v1')
+      ecdh.setPrivateKey(privateKey)
+      return new Uint8Array(ecdh.getPublicKey(undefined, 'uncompressed'))
+    },
+  })
+}
+
+export declare namespace engine {
+  /** Every `P256` primitive this module implements. */
+  type ReturnType = {
+    getPublicKey: NonNullable<Engine.Ecdsa['getPublicKey']>
+  }
+
+  type ErrorType = Errors.GlobalErrorType
+}

package/src/node/X25519.ts

@@ -0,0 +1,93 @@
+import * as crypto from 'node:crypto'
+import type * as Engine from '../core/Engine.js'
+import type * as Errors from '../core/Errors.js'
+
+export * from '../core/X25519.js'
+
+const privateKeyPrefix = Buffer.from('302e020100300506032b656e04220420', 'hex')
+const publicKeyPrefix = Buffer.from('302a300506032b656e032100', 'hex')
+
+/**
+ * Creates a Node.js implementation of the [`X25519`](/api/X25519) engine slot,
+ * without installing it.
+ *
+ * Random key generation remains on Ox's default implementation.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { X25519 } from 'ox/node'
+ *
+ * await Engine.install({ X25519: X25519.engine() })
+ *
+ * X25519.getPublicKey({ privateKey: '0x...' })
+ * ```
+ *
+ * @returns The raw `X25519` engine slot.
+ */
+export function engine(): Promise<engine.ReturnType> {
+  return Promise.resolve({
+    getPublicKey: (privateKey) =>
+      rawPublicKey(crypto.createPublicKey(toPrivateKey(privateKey))),
+    getSharedSecret: (privateKey, publicKey) =>
+      copyAndClear(
+        crypto.diffieHellman({
+          privateKey: toPrivateKey(privateKey),
+          publicKey: toPublicKey(publicKey),
+        }),
+      ),
+  })
+}
+
+export declare namespace engine {
+  /** Every `X25519` primitive this module implements. */
+  type ReturnType = {
+    [key in 'getPublicKey' | 'getSharedSecret']-?: NonNullable<Engine.Ecdh[key]>
+  }
+
+  type ErrorType = Errors.GlobalErrorType
+}
+
+function copyAndClear(value: Buffer): Uint8Array {
+  try {
+    return Uint8Array.from(value)
+  } finally {
+    value.fill(0)
+  }
+}
+
+function assertLength(key: Uint8Array, type: 'private' | 'public'): void {
+  if (key.length !== 32)
+    throw new RangeError(
+      `X25519 ${type} key must be 32 bytes, got ${key.length}`,
+    )
+}
+
+function rawPublicKey(publicKey: crypto.KeyObject): Uint8Array {
+  const der = publicKey.export({ format: 'der', type: 'spki' })
+  return Uint8Array.from(der.subarray(-32))
+}
+
+function toPrivateKey(privateKey: Uint8Array): crypto.KeyObject {
+  assertLength(privateKey, 'private')
+  const der = Buffer.concat([privateKeyPrefix, privateKey])
+  try {
+    return crypto.createPrivateKey({
+      format: 'der',
+      key: der,
+      type: 'pkcs8',
+    })
+  } finally {
+    der.fill(0)
+  }
+}
+
+function toPublicKey(publicKey: Uint8Array): crypto.KeyObject {
+  assertLength(publicKey, 'public')
+  return crypto.createPublicKey({
+    format: 'der',
+    key: Buffer.concat([publicKeyPrefix, publicKey]),
+    type: 'spki',
+  })
+}

package/src/node/_test/Curves.fuzz.ts

@@ -0,0 +1,76 @@
+import { fc, test } from '@fast-check/vitest'
+import { ed25519, x25519 } from '@noble/curves/ed25519.js'
+import { p256 } from '@noble/curves/nist.js'
+import { describe, expect } from 'vp/test'
+import { numRuns } from '../../../test/fuzz/numRuns.js'
+import * as Ed25519 from '../Ed25519.js'
+import * as P256 from '../P256.js'
+import * as X25519 from '../X25519.js'
+
+const arbitraryBytes = fc.uint8Array({ maxLength: 512 })
+const arbitraryKey = fc.uint8Array({ maxLength: 32, minLength: 32 })
+const arbitraryP256PrivateKey = fc
+  .tuple(
+    fc.integer({ max: 0xfe, min: 1 }),
+    fc.uint8Array({ maxLength: 31, minLength: 31 }),
+  )
+  .map(([first, rest]) => Uint8Array.of(first, ...rest))
+
+describe('Ed25519', () => {
+  test.prop({ payload: arbitraryBytes, privateKey: arbitraryKey }, { numRuns })(
+    'matches the default for arbitrary offset views',
+    async (options) => {
+      const engine = await Ed25519.engine()
+      const payload = offsetView(options.payload)
+      const privateKey = offsetView(options.privateKey)
+
+      expect(engine.getPublicKey(privateKey)).toEqual(
+        ed25519.getPublicKey(privateKey),
+      )
+      expect(engine.sign(payload, privateKey)).toEqual(
+        ed25519.sign(payload, privateKey),
+      )
+      expect(engine.toMontgomerySecret(privateKey)).toEqual(
+        ed25519.utils.toMontgomerySecret(privateKey),
+      )
+    },
+  )
+})
+
+describe('X25519', () => {
+  test.prop(
+    { privateKey: arbitraryKey, publicKeySeed: arbitraryKey },
+    { numRuns },
+  )('matches the default for arbitrary offset views', async (options) => {
+    const engine = await X25519.engine()
+    const privateKey = offsetView(options.privateKey)
+    const publicKey = offsetView(x25519.getPublicKey(options.publicKeySeed))
+
+    expect(engine.getPublicKey(privateKey)).toEqual(
+      x25519.getPublicKey(privateKey),
+    )
+    expect(engine.getSharedSecret(privateKey, publicKey)).toEqual(
+      x25519.getSharedSecret(privateKey, publicKey),
+    )
+  })
+})
+
+describe('P256', () => {
+  test.prop({ privateKey: arbitraryP256PrivateKey }, { numRuns })(
+    'matches the default for arbitrary offset views',
+    async (options) => {
+      const engine = await P256.engine()
+      const privateKey = offsetView(options.privateKey)
+
+      expect(engine.getPublicKey(privateKey)).toEqual(
+        p256.getPublicKey(privateKey, false),
+      )
+    },
+  )
+})
+
+function offsetView(value: Uint8Array): Uint8Array {
+  const bytes = new Uint8Array(value.length + 4).fill(0xff)
+  bytes.set(value, 2)
+  return bytes.subarray(2, -2)
+}

package/src/node/_test/Ed25519.test-d.ts

@@ -0,0 +1,35 @@
+import { expectTypeOf, test } from 'vp/test'
+import type * as Engine from '../../core/Engine.js'
+import * as core_Ed25519 from '../../core/Ed25519.js'
+import * as NodeEd25519 from '../Ed25519.js'
+
+type Slot = Awaited<ReturnType<typeof NodeEd25519.engine>>
+
+test('every implemented primitive is present', () => {
+  expectTypeOf<Slot['getPublicKey']>().toEqualTypeOf<
+    (privateKey: Uint8Array) => Uint8Array
+  >()
+  expectTypeOf<Slot['sign']>().toEqualTypeOf<
+    (payload: Uint8Array, privateKey: Uint8Array) => Uint8Array
+  >()
+  expectTypeOf<Slot['toMontgomerySecret']>().toEqualTypeOf<
+    (privateKey: Uint8Array) => Uint8Array
+  >()
+})
+
+test('unsupported primitives are absent', () => {
+  expectTypeOf<Slot>().not.toHaveProperty('randomSecretKey')
+  expectTypeOf<Slot>().not.toHaveProperty('toMontgomery')
+  expectTypeOf<Slot>().not.toHaveProperty('verify')
+})
+
+test('the result is the raw slot', () => {
+  expectTypeOf<{ Ed25519: Slot }>().toExtend<Engine.Engine>()
+})
+
+test('the Node namespace exposes the public Ed25519 API', () => {
+  expectTypeOf(NodeEd25519.getPublicKey).toEqualTypeOf(
+    core_Ed25519.getPublicKey,
+  )
+  expectTypeOf<typeof NodeEd25519>().not.toHaveProperty('create')
+})

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

@@ -0,0 +1,220 @@
+import * as crypto from 'node:crypto'
+import * as fs from 'node:fs'
+import { ed25519 } from '@noble/curves/ed25519.js'
+import { Hex } from 'ox'
+import { describe, expect, test } from 'vp/test'
+import * as Ed25519 from '../Ed25519.js'
+
+type Zip215Vector = {
+  sig_bytes: string
+  valid_legacy: boolean
+  valid_zip215: boolean
+  vk_bytes: string
+}
+
+const publicKeyPrefix = Buffer.from('302a300506032b6570032100', 'hex')
+const zip215Text = fs.readFileSync(
+  new URL('../../../test/vectors/ed25519/zip215.json', import.meta.url),
+  'utf8',
+)
+const zip215 = JSON.parse(zip215Text) as readonly Zip215Vector[]
+
+const vectors = [
+  {
+    payload: '',
+    privateKey:
+      '9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60',
+  },
+  {
+    payload: '72',
+    privateKey:
+      '4ccd089b28ff96da9db6c346ec114e0f5b8a319f35aba624da8cf6ed4fb8a6fb',
+  },
+] as const
+
+describe('engine', () => {
+  test('behavior: exposes only primitives compatible with Ox semantics', async () => {
+    const engine = await Ed25519.engine()
+
+    // Node verification is deliberately absent because it does not implement
+    // the ZIP-215 rules used by Ox's default verifier.
+    expect(Object.keys(engine).sort()).toMatchInlineSnapshot(`
+      [
+        "getPublicKey",
+        "sign",
+        "toMontgomerySecret",
+      ]
+    `)
+  })
+
+  test('behavior: matches RFC 8032 test vectors', async () => {
+    const engine = await Ed25519.engine()
+
+    expect(
+      vectors.map(({ payload, privateKey }) => ({
+        publicKey: Hex.fromBytes(engine.getPublicKey(fromHex(privateKey))),
+        signature: Hex.fromBytes(
+          engine.sign(fromHex(payload), fromHex(privateKey)),
+        ),
+      })),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "publicKey": "0xd75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a",
+          "signature": "0xe5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b",
+        },
+        {
+          "publicKey": "0x3d4017c3e843895a92b70aa74d1b7ebc9c982ccf2ec4968cc0cd55f12af4660c",
+          "signature": "0x92a009a9f0d4cab8720e820b5f642540a2b27b5416503f8fb3762223ebdb69da085ac1e43e15996e458f3613d0f11d8c387b2eaeb4302aeeb00d291612bb0c00",
+        },
+      ]
+    `)
+  })
+
+  test('behavior: omits verification that disagrees with ZIP-215', async () => {
+    const engine = await Ed25519.engine()
+    const digest = crypto
+      .createHash('sha256')
+      .update(JSON.stringify(zip215))
+      .digest('hex')
+    const message = new TextEncoder().encode('Zcash')
+    let defaultAccepted = 0
+    let nodeAccepted = 0
+
+    for (const vector of zip215) {
+      const publicKey = fromHex(vector.vk_bytes)
+      const signature = fromHex(vector.sig_bytes)
+      if (ed25519.verify(signature, message, publicKey)) defaultAccepted++
+      if (nodeVerify(vector, message)) nodeAccepted++
+    }
+
+    expect({
+      defaultAccepted,
+      digest,
+      legacyAccepted: zip215.filter((vector) => vector.valid_legacy).length,
+      nodeDisagrees: nodeAccepted < defaultAccepted,
+      vectors: zip215.length,
+    }).toMatchInlineSnapshot(`
+      {
+        "defaultAccepted": 196,
+        "digest": "e99ef30c602df87b8d5970dea07f35bcd5993b003e5682ca2c8dc4dab9de4335",
+        "legacyAccepted": 3,
+        "nodeDisagrees": true,
+        "vectors": 196,
+      }
+    `)
+    expect('verify' in engine).toMatchInlineSnapshot('false')
+  })
+
+  test('behavior: matches the default across messages and private keys', async () => {
+    const engine = await Ed25519.engine()
+
+    for (const [index, { privateKey }] of vectors.entries()) {
+      const key = fromHex(privateKey)
+      for (const size of [0, 1, 31, 32, 63, 64, 65, 255]) {
+        const payload = Uint8Array.from(
+          { length: size },
+          (_, offset) => (offset * 29 + index) % 251,
+        )
+        expect(engine.sign(payload, key)).toEqual(ed25519.sign(payload, key))
+      }
+      expect(engine.getPublicKey(key)).toEqual(ed25519.getPublicKey(key))
+      expect(engine.toMontgomerySecret(key)).toEqual(
+        ed25519.utils.toMontgomerySecret(key),
+      )
+    }
+  })
+
+  test('behavior: respects typed-array offsets without mutating inputs', async () => {
+    const engine = await Ed25519.engine()
+    const privateKey = offsetView(fromHex(vectors[0].privateKey))
+    const payload = offsetView(
+      Uint8Array.from({ length: 65 }, (_, index) => (index * 17) % 251),
+    )
+    const privateKeyBefore = privateKey.slice()
+    const payloadBefore = payload.slice()
+
+    expect(engine.getPublicKey(privateKey)).toEqual(
+      ed25519.getPublicKey(privateKey),
+    )
+    expect(engine.sign(payload, privateKey)).toEqual(
+      ed25519.sign(payload, privateKey),
+    )
+    expect(engine.toMontgomerySecret(privateKey)).toEqual(
+      ed25519.utils.toMontgomerySecret(privateKey),
+    )
+    expect({ payload, privateKey }).toEqual({
+      payload: payloadBefore,
+      privateKey: privateKeyBefore,
+    })
+  })
+
+  test('behavior: rejects malformed private-key lengths', async () => {
+    const engine = await Ed25519.engine()
+
+    for (const size of [0, 1, 31, 33, 64]) {
+      const privateKey = new Uint8Array(size)
+      expect(() => engine.getPublicKey(privateKey)).toThrowError(
+        `Ed25519 private key must be 32 bytes, got ${size}`,
+      )
+      expect(() => engine.sign(new Uint8Array(), privateKey)).toThrowError(
+        `Ed25519 private key must be 32 bytes, got ${size}`,
+      )
+      expect(() => engine.toMontgomerySecret(privateKey)).toThrowError(
+        `Ed25519 private key must be 32 bytes, got ${size}`,
+      )
+    }
+  })
+
+  test('behavior: returns owned Uint8Array values', async () => {
+    const engine = await Ed25519.engine()
+    const privateKey = fromHex(vectors[0].privateKey)
+    const outputs = [
+      engine.getPublicKey(privateKey),
+      engine.sign(new Uint8Array(), privateKey),
+      engine.toMontgomerySecret(privateKey),
+    ]
+
+    expect(outputs.map((output) => output.constructor === Uint8Array))
+      .toMatchInlineSnapshot(`
+      [
+        true,
+        true,
+        true,
+      ]
+    `)
+    expect(
+      engine.getPublicKey(privateKey) === engine.getPublicKey(privateKey),
+    ).toMatchInlineSnapshot('false')
+  })
+
+  test('behavior: returns a fresh engine', async () => {
+    const first = await Ed25519.engine()
+    const second = await Ed25519.engine()
+
+    expect(first === second).toMatchInlineSnapshot('false')
+  })
+})
+
+function fromHex(value: string): Uint8Array {
+  return Hex.toBytes(`0x${value}`)
+}
+
+function offsetView(value: Uint8Array): Uint8Array {
+  const bytes = new Uint8Array(value.length + 4).fill(0xff)
+  bytes.set(value, 2)
+  return bytes.subarray(2, -2)
+}
+
+function nodeVerify(vector: Zip215Vector, message: Uint8Array): boolean {
+  try {
+    const publicKey = crypto.createPublicKey({
+      format: 'der',
+      key: Buffer.concat([publicKeyPrefix, fromHex(vector.vk_bytes)]),
+      type: 'spki',
+    })
+    return crypto.verify(null, message, publicKey, fromHex(vector.sig_bytes))
+  } catch {
+    return false
+  }
+}

package/src/node/_test/Engine.test-d.ts

@@ -0,0 +1,28 @@
+import { Engine } from 'ox/node'
+import { expectTypeOf, test } from 'vp/test'
+import * as CoreEngine from '../../core/Engine.js'
+
+type Installed = Awaited<ReturnType<typeof Engine.install>>
+type Uninstalled = Awaited<ReturnType<typeof Engine.engine>>
+
+test('install and engine expose the same precise engine', () => {
+  expectTypeOf<Installed>().toEqualTypeOf<Uninstalled>()
+  expectTypeOf<Installed['Hash']['sha256']>().toEqualTypeOf<
+    (input: Uint8Array) => Uint8Array
+  >()
+})
+
+test('the Node Engine namespace exposes synchronous core operations', () => {
+  expectTypeOf(Engine.get).toEqualTypeOf(CoreEngine.get)
+  expectTypeOf(Engine.InvalidSlotValueError).toEqualTypeOf(
+    CoreEngine.InvalidSlotValueError,
+  )
+  expectTypeOf(Engine.reset).toEqualTypeOf(CoreEngine.reset)
+  expectTypeOf(Engine.set).toEqualTypeOf(CoreEngine.set)
+  expectTypeOf(Engine.with).toEqualTypeOf(CoreEngine.with)
+})
+
+test('the replaced aliases are absent', () => {
+  expectTypeOf<typeof Engine>().not.toHaveProperty('create')
+  expectTypeOf<typeof Engine>().not.toHaveProperty('load')
+})

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

@@ -1,22 +1,27 @@
-import { Engine as CoreEngine, Hash } from 'ox'
-import { Engine } from 'ox/node'
+import { Engine as CoreEngine } from 'ox'
+import { Engine, Hash } from 'ox/node'
 import { describe, expect, test } from 'vp/test'
 
-describe('create', () => {
+describe('engine', () => {
   test('behavior: does not install', async () => {
-    const engine = await Engine.create()
+    const engine = await Engine.engine()
 
     expect(Object.keys(engine)).toMatchInlineSnapshot(`
       [
+        "Ed25519",
         "Hash",
+        "Keystore",
+        "Mnemonic",
+        "P256",
+        "X25519",
       ]
     `)
-    expect(CoreEngine.get()).toMatchInlineSnapshot('{}')
+    expect(Engine.get()).toMatchInlineSnapshot('{}')
   })
 
   test('behavior: installs for the duration of a call', async () => {
-    const node = await Engine.create()
-    const digest = CoreEngine.with(node, () => Hash.sha256('0xdeadbeef'))
+    const node = await Engine.engine()
+    const digest = Engine.with(node, () => Hash.sha256('0xdeadbeef'))
 
     expect(digest).toMatchInlineSnapshot(
       `"0x5f78c33274e43fa9de5659265c1d917e25c03722dcb0b8d27db8d5feaa813953"`,
@@ -25,23 +30,53 @@ describe('create', () => {
   })
 })
 
-describe('load', () => {
+describe('install', () => {
   test('behavior: installs and returns what it installed', async () => {
-    const engine = await Engine.load()
+    const engine = await Engine.install()
 
-    expect(Object.keys(CoreEngine.get())).toEqual(Object.keys(engine))
-    expect(Object.keys(CoreEngine.get().Hash ?? {}).sort())
-      .toMatchInlineSnapshot(`
-      [
-        "hmacSha256",
-        "ripemd160",
-        "sha256",
-      ]
-    `)
+    expect(Engine.get()).toEqual(CoreEngine.get())
+    expect(Object.keys(Engine.get())).toEqual(Object.keys(engine))
+    expect(
+      Object.fromEntries(
+        Object.entries(Engine.get()).map(([slot, value]) => [
+          slot,
+          Object.keys(value ?? {}).sort(),
+        ]),
+      ),
+    ).toMatchInlineSnapshot(`
+        {
+          "Ed25519": [
+            "getPublicKey",
+            "sign",
+            "toMontgomerySecret",
+          ],
+          "Hash": [
+            "hmacSha256",
+            "ripemd160",
+            "sha256",
+          ],
+          "Keystore": [
+            "aesCtrDecrypt",
+            "aesCtrEncrypt",
+            "pbkdf2Sha256",
+            "pbkdf2Sha256Async",
+          ],
+          "Mnemonic": [
+            "toSeed",
+          ],
+          "P256": [
+            "getPublicKey",
+          ],
+          "X25519": [
+            "getPublicKey",
+            "getSharedSecret",
+          ],
+        }
+      `)
   })
 
   test('behavior: leaves unsupported primitives on the default', async () => {
-    await Engine.load()
+    await Engine.install()
 
     expect(Hash.keccak256('0xdeadbeef')).toMatchInlineSnapshot(
       `"0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1"`,
@@ -49,13 +84,18 @@ describe('load', () => {
   })
 
   test('behavior: merges with later engines', async () => {
-    await Engine.load()
-    CoreEngine.set({ Mnemonic: { toSeed: () => new Uint8Array(64) } })
+    await Engine.install()
+    Engine.set({ Bls: { randomSecretKey: () => new Uint8Array(32) } })
 
-    expect(Object.keys(CoreEngine.get()).sort()).toMatchInlineSnapshot(`
+    expect(Object.keys(Engine.get()).sort()).toMatchInlineSnapshot(`
       [
+        "Bls",
+        "Ed25519",
         "Hash",
+        "Keystore",
         "Mnemonic",
+        "P256",
+        "X25519",
       ]
     `)
   })