ox 1.1.2 → 1.3.0

package/src/wasm/Secp256k1.ts

@@ -0,0 +1,248 @@
+import type * as Engine from '../core/Engine.js'
+import * as Errors from '../core/Errors.js'
+import * as internal from './internal/instantiate.js'
+import * as secp256k1 from './internal/secp256k1.js'
+
+export * from '../core/Secp256k1.js'
+export { MemoryError } from './internal/instantiate.js'
+
+const privateKeySize = 32
+const publicKeySize = 65
+const sharedSecretSize = 33
+const compactSignatureSize = 64
+const recoveredSignatureSize = 65
+const maxRawMessageSize = 8192
+
+/**
+ * Compiles WASM implementations of deterministic
+ * [`Secp256k1`](/api/Secp256k1) primitives, without installing them.
+ *
+ * Random key generation remains on Ox's host-backed default implementation.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Secp256k1 } from 'ox/wasm'
+ *
+ * await Engine.install({ Secp256k1: Secp256k1.engine() })
+ *
+ * Secp256k1.getPublicKey({ privateKey: '0x...' })
+ * ```
+ *
+ * @returns The WASM implementation of the deterministic `Secp256k1` primitives.
+ */
+export async function engine(): Promise<engine.ReturnType> {
+  const module = await secp256k1.load()
+
+  return {
+    getPublicKey(privateKey) {
+      assertLength(privateKey, privateKeySize, 'private key')
+      const size = privateKeySize + publicKeySize
+      module.reserve(size)
+      const privateKeyPtr = module.heapBase
+      const publicKeyPtr = privateKeyPtr + privateKeySize
+      try {
+        module.view().set(privateKey, privateKeyPtr)
+        if (
+          module.exports.secp256k1_get_public_key(
+            privateKeyPtr,
+            publicKeyPtr,
+          ) !== 1
+        )
+          throw new InvalidInputError({ operation: 'getPublicKey' })
+        return module.view().slice(publicKeyPtr, publicKeyPtr + publicKeySize)
+      } finally {
+        module.exports.zero(privateKeyPtr, size)
+      }
+    },
+    getSharedSecret(privateKey, publicKey) {
+      assertLength(privateKey, privateKeySize, 'private key')
+      assertPublicKeyLength(publicKey)
+      const size = privateKeySize + publicKey.length + sharedSecretSize
+      module.reserve(size)
+      const privateKeyPtr = module.heapBase
+      const publicKeyPtr = privateKeyPtr + privateKeySize
+      const sharedSecretPtr = publicKeyPtr + publicKey.length
+      try {
+        const memory = module.view()
+        memory.set(privateKey, privateKeyPtr)
+        memory.set(publicKey, publicKeyPtr)
+        if (
+          module.exports.secp256k1_get_shared_secret(
+            privateKeyPtr,
+            publicKeyPtr,
+            publicKey.length,
+            sharedSecretPtr,
+          ) !== 1
+        )
+          throw new InvalidInputError({ operation: 'getSharedSecret' })
+        return module
+          .view()
+          .slice(sharedSecretPtr, sharedSecretPtr + sharedSecretSize)
+      } finally {
+        module.exports.zero(privateKeyPtr, size)
+      }
+    },
+    recoverPublicKey(signature, payload) {
+      assertLength(signature, recoveredSignatureSize, 'signature')
+      assertRawMessageLength(payload)
+      const size = recoveredSignatureSize + payload.length + publicKeySize
+      module.reserve(size)
+      const signaturePtr = module.heapBase
+      const payloadPtr = signaturePtr + recoveredSignatureSize
+      const publicKeyPtr = payloadPtr + payload.length
+      try {
+        const memory = module.view()
+        memory.set(signature, signaturePtr)
+        memory.set(payload, payloadPtr)
+        if (
+          module.exports.secp256k1_recover_public_key(
+            signaturePtr,
+            payloadPtr,
+            payload.length,
+            publicKeyPtr,
+          ) !== 1
+        )
+          throw new InvalidInputError({ operation: 'recoverPublicKey' })
+        return module.view().slice(publicKeyPtr, publicKeyPtr + publicKeySize)
+      } finally {
+        module.exports.zero(signaturePtr, size)
+      }
+    },
+    sign(payload, privateKey, options) {
+      assertLength(privateKey, privateKeySize, 'private key')
+      if (!options.prehash) assertRawMessageLength(payload)
+      const entropy =
+        options.extraEntropy === true
+          ? crypto.getRandomValues(new Uint8Array(privateKeySize))
+          : options.extraEntropy === false
+            ? undefined
+            : options.extraEntropy
+      const entropySize = entropy?.length ?? 0
+      const size =
+        payload.length + privateKeySize + entropySize + recoveredSignatureSize
+      module.reserve(size)
+      const payloadPtr = module.heapBase
+      const privateKeyPtr = payloadPtr + payload.length
+      const entropyPtr = entropy ? privateKeyPtr + privateKeySize : 0
+      const signaturePtr = privateKeyPtr + privateKeySize + entropySize
+      try {
+        const memory = module.view()
+        memory.set(payload, payloadPtr)
+        memory.set(privateKey, privateKeyPtr)
+        if (entropy) memory.set(entropy, entropyPtr)
+        if (
+          module.exports.secp256k1_sign(
+            payloadPtr,
+            payload.length,
+            privateKeyPtr,
+            entropyPtr,
+            entropySize,
+            Number(options.prehash),
+            signaturePtr,
+          ) !== 1
+        )
+          throw new InvalidInputError({ operation: 'sign' })
+        return module
+          .view()
+          .slice(signaturePtr, signaturePtr + recoveredSignatureSize)
+      } finally {
+        module.exports.zero(payloadPtr, size)
+      }
+    },
+    verify(signature, payload, publicKey, options) {
+      assertLength(signature, compactSignatureSize, 'signature')
+      assertPublicKeyLength(publicKey)
+      if (!options.prehash && payload.length > maxRawMessageSize) return false
+      const size = compactSignatureSize + payload.length + publicKey.length
+      module.reserve(size)
+      const signaturePtr = module.heapBase
+      const payloadPtr = signaturePtr + compactSignatureSize
+      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.secp256k1_verify(
+            signaturePtr,
+            payloadPtr,
+            payload.length,
+            publicKeyPtr,
+            publicKey.length,
+            Number(options.prehash),
+          ) === 1
+        )
+      } finally {
+        module.exports.zero(signaturePtr, size)
+      }
+    },
+  }
+}
+
+export declare namespace engine {
+  /** Every `Secp256k1` primitive this module implements. */
+  type ReturnType = {
+    [key in
+      | 'getPublicKey'
+      | 'getSharedSecret'
+      | 'recoverPublicKey'
+      | 'sign'
+      | 'verify']-?: NonNullable<Engine.Ecdsa[key]>
+  }
+
+  type ErrorType =
+    | InvalidInputError
+    | internal.MemoryError
+    | Errors.GlobalErrorType
+}
+
+function assertLength(value: Uint8Array, length: number, name: string): void {
+  if (value.length !== length)
+    throw new RangeError(
+      `Secp256k1 ${name} must be ${length} bytes, got ${value.length}`,
+    )
+}
+
+function assertPublicKeyLength(publicKey: Uint8Array): void {
+  if (
+    publicKey.length !== sharedSecretSize &&
+    publicKey.length !== publicKeySize
+  )
+    throw new RangeError(
+      `Secp256k1 public key must be 33 or 65 bytes, got ${publicKey.length}`,
+    )
+}
+
+function assertRawMessageLength(payload: Uint8Array): void {
+  if (payload.length > maxRawMessageSize)
+    throw new RangeError(
+      `Secp256k1 unhashed payload must not exceed ${maxRawMessageSize} bytes, got ${payload.length}`,
+    )
+}
+
+/**
+ * Thrown when libsecp256k1 rejects a key or recovered signature.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Secp256k1 } from 'ox/wasm'
+ *
+ * try {
+ *   const engine = await Secp256k1.engine()
+ *   engine.getPublicKey(new Uint8Array(32))
+ * } catch (error) {
+ *   if (error instanceof Secp256k1.InvalidInputError)
+ *     console.error(error.message)
+ * }
+ * ```
+ */
+export class InvalidInputError extends Errors.BaseError {
+  override readonly name = 'Secp256k1.InvalidInputError'
+
+  constructor({ operation }: { operation: string }) {
+    super(`WASM secp256k1 ${operation} received invalid input.`)
+  }
+}

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

@@ -10,9 +10,11 @@ test('install and engine expose the same precise engine', () => {
   expectTypeOf<Installed['Hash']['sha256']>().toEqualTypeOf<
     (input: Uint8Array) => Uint8Array
   >()
+  expectTypeOf<Installed['Keystore']>().not.toHaveProperty('scrypt')
 })
 
 test('the WASM Engine namespace exposes synchronous core operations', () => {
+  expectTypeOf<Engine.HashState>().toEqualTypeOf<CoreEngine.HashState>()
   expectTypeOf(Engine.get).toEqualTypeOf(CoreEngine.get)
   expectTypeOf(Engine.InvalidSlotValueError).toEqualTypeOf(
     CoreEngine.InvalidSlotValueError,

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

@@ -75,6 +75,11 @@ describe('install', () => {
           ],
           "Hash": [
             "blake3",
+            "createBlake3",
+            "createHmacSha256",
+            "createKeccak256",
+            "createRipemd160",
+            "createSha256",
             "hmacSha256",
             "keccak256",
             "ripemd160",

package/src/wasm/_test/Hash.browser.test.ts

@@ -27,6 +27,28 @@ describe('engine', () => {
     }
   })
 
+  test('behavior: incremental states clone and cross block boundaries', async () => {
+    const engine = await WasmHash.engine()
+    const prefix = new Uint8Array(137).fill(1)
+    const left = new Uint8Array(1025).fill(2)
+    const right = new Uint8Array(65).fill(3)
+    const state = engine.createBlake3()
+    state.update(prefix.subarray(0, 1))
+    state.update(prefix.subarray(1, 136))
+    state.update(prefix.subarray(136))
+    const clone = state.clone()
+    state.update(left)
+    clone.update(right)
+
+    const output = new Uint8Array(32)
+    state.digestInto(output)
+    expect(output).toEqual(blake3(new Uint8Array([...prefix, ...left])))
+
+    const clonedOutput = new Uint8Array(32)
+    clone.digestInto(clonedOutput)
+    expect(clonedOutput).toEqual(blake3(new Uint8Array([...prefix, ...right])))
+  })
+
   test('behavior: grows memory in a real browser, then hashes a small input', async () => {
     const engine = await WasmHash.engine()
 
@@ -44,9 +66,18 @@ describe('engine', () => {
   test('behavior: ox uses the WASM implementation once installed', async () => {
     await Engine.install({ Hash: WasmHash.engine() })
     try {
+      expect(Hash.blake3('0xdeadbeef')).toBe(
+        '0x53147f3ce49ed4f60dfa5b9654c36ba6103c11f5737df3dabd4cbd296c4161bd',
+      )
       expect(Hash.keccak256('0xdeadbeef')).toBe(
         '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1',
       )
+      const state = Hash.createKeccak256()
+      state.update('0xdead')
+      state.update('0xbeef')
+      expect(state.digest()).toBe(
+        '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1',
+      )
     } finally {
       Engine.reset()
     }

package/src/wasm/_test/Hash.test-d.ts

@@ -21,6 +21,21 @@ test('every primitive is present, so callers need no assertion', () => {
   expectTypeOf<Slot['hmacSha256']>().toEqualTypeOf<
     (key: Uint8Array, message: Uint8Array) => Uint8Array
   >()
+  expectTypeOf<Slot['createBlake3']>().toEqualTypeOf<
+    () => CoreEngine.HashState
+  >()
+  expectTypeOf<Slot['createHmacSha256']>().toEqualTypeOf<
+    (key: Uint8Array) => CoreEngine.HashState
+  >()
+  expectTypeOf<Slot['createKeccak256']>().toEqualTypeOf<
+    () => CoreEngine.HashState
+  >()
+  expectTypeOf<Slot['createRipemd160']>().toEqualTypeOf<
+    () => CoreEngine.HashState
+  >()
+  expectTypeOf<Slot['createSha256']>().toEqualTypeOf<
+    () => CoreEngine.HashState
+  >()
 })
 
 test('the result is the raw slot, so `Engine.install` accepts it', () => {
@@ -28,6 +43,8 @@ test('the result is the raw slot, so `Engine.install` accepts it', () => {
 })
 
 test('the WASM namespace exposes the public Hash API', () => {
+  expectTypeOf(WasmHash.blake3).toEqualTypeOf(CoreHash.blake3)
+  expectTypeOf(WasmHash.createBlake3).toEqualTypeOf(CoreHash.createBlake3)
   expectTypeOf(WasmHash.sha256).toEqualTypeOf(CoreHash.sha256)
   expectTypeOf<typeof WasmHash>().not.toHaveProperty('create')
 })

package/src/wasm/_test/Hash.test.ts

@@ -8,8 +8,14 @@ import { Hash as WasmHash } from 'ox/wasm'
 import { beforeAll, describe, expect, test } from 'vp/test'
 import { wasmBase64 as blake3WasmBase64 } from '../internal/blake3.wasm.js'
 import * as blake3_internal from '../internal/blake3.js'
-import { hmacSha256ScratchSize, wasmBase64 } from '../internal/hashes.wasm.js'
+import { blake3StateSize } from '../internal/blake3.wasm.js'
+import {
+  hmacSha256ScratchSize,
+  hmacSha256StateSize,
+  wasmBase64,
+} from '../internal/hashes.wasm.js'
 import * as hash from '../internal/hash.js'
+import * as hashes_internal from '../internal/hashes.js'
 import * as internal from '../internal/instantiate.js'
 
 let engine: WasmHash.engine.ReturnType
@@ -23,6 +29,11 @@ describe('engine', () => {
     expect(Object.keys(await WasmHash.engine())).toMatchInlineSnapshot(`
       [
         "blake3",
+        "createBlake3",
+        "createHmacSha256",
+        "createKeccak256",
+        "createRipemd160",
+        "createSha256",
         "hmacSha256",
         "keccak256",
         "ripemd160",
@@ -58,6 +69,79 @@ function input(size: number) {
   return new Uint8Array(size).map((_, index) => (index * 37 + 11) & 0xff)
 }
 
+type HashState = ReturnType<WasmHash.engine.ReturnType['createSha256']>
+
+type IncrementalCase = {
+  create: () => HashState
+  digestSize: number
+  name: string
+  oneShot: (input: Uint8Array) => Uint8Array
+  wasmOneShot: (input: Uint8Array) => Uint8Array
+}
+
+function concat(...values: readonly Uint8Array[]) {
+  const output = new Uint8Array(
+    values.reduce((length, value) => length + value.length, 0),
+  )
+  let offset = 0
+  for (const value of values) {
+    output.set(value, offset)
+    offset += value.length
+  }
+  return output
+}
+
+function align8(value: number) {
+  return Math.ceil(value / 8) * 8
+}
+
+function digest(state: HashState, size: number) {
+  const output = new Uint8Array(size)
+  state.digestInto(output)
+  return output
+}
+
+function incrementalCases(): readonly IncrementalCase[] {
+  const key = input(100)
+  return [
+    {
+      create: () => engine.createBlake3(),
+      digestSize: 32,
+      name: 'blake3',
+      oneShot: blake3,
+      wasmOneShot: (value) => engine.blake3(value),
+    },
+    {
+      create: () => engine.createHmacSha256(key),
+      digestSize: 32,
+      name: 'hmacSha256',
+      oneShot: (value) => hmac(sha256, key, value),
+      wasmOneShot: (value) => engine.hmacSha256(key, value),
+    },
+    {
+      create: () => engine.createKeccak256(),
+      digestSize: 32,
+      name: 'keccak256',
+      oneShot: keccak_256,
+      wasmOneShot: (value) => engine.keccak256(value),
+    },
+    {
+      create: () => engine.createRipemd160(),
+      digestSize: 20,
+      name: 'ripemd160',
+      oneShot: ripemd160,
+      wasmOneShot: (value) => engine.ripemd160(value),
+    },
+    {
+      create: () => engine.createSha256(),
+      digestSize: 32,
+      name: 'sha256',
+      oneShot: sha256,
+      wasmOneShot: (value) => engine.sha256(value),
+    },
+  ]
+}
+
 describe('Hash', () => {
   test.each(sizes)('blake3 matches the default at %i bytes', (size) => {
     expect(engine.blake3(input(size))).toEqual(blake3(input(size)))
@@ -86,6 +170,97 @@ describe('Hash', () => {
     },
   )
 
+  test.each(incrementalCases())(
+    '$name matches arbitrary chunk boundaries',
+    ({ create, digestSize, oneShot }) => {
+      const message = input(4097)
+      const snapshot = message.slice()
+      const chunks = [0, 1, 7, 55, 64, 129, 1023, 136, 2]
+      const state = create()
+      let offset = 0
+      let index = 0
+      while (offset < message.length) {
+        const length = Math.min(
+          chunks[index++ % chunks.length]!,
+          message.length - offset,
+        )
+        state.update(message.subarray(offset, offset + length))
+        offset += length
+      }
+
+      expect(digest(state, digestSize)).toEqual(oneShot(message))
+      expect(message).toEqual(snapshot)
+    },
+  )
+
+  test.each(incrementalCases())(
+    '$name clones an independent prefix',
+    ({ create, digestSize, oneShot }) => {
+      const prefix = input(137)
+      const left = input(63)
+      const right = input(1025)
+      const state = create()
+      state.update(prefix)
+      const clone = state.clone()
+      state.update(left)
+      clone.update(right)
+
+      expect(digest(state, digestSize)).toEqual(oneShot(concat(prefix, left)))
+      expect(digest(clone, digestSize)).toEqual(oneShot(concat(prefix, right)))
+    },
+  )
+
+  test.each(incrementalCases())(
+    '$name keeps interleaved states independent',
+    ({ create, digestSize, oneShot }) => {
+      const a = input(2049)
+      const b = input(271)
+      const stateA = create()
+      const stateB = create()
+
+      stateA.update(a.subarray(0, 55))
+      stateB.update(b.subarray(0, 136))
+      stateA.update(a.subarray(55, 1024))
+      stateB.update(b.subarray(136))
+      stateA.update(a.subarray(1024))
+
+      expect(digest(stateB, digestSize)).toEqual(oneShot(b))
+      expect(digest(stateA, digestSize)).toEqual(oneShot(a))
+    },
+  )
+
+  test.each(incrementalCases())(
+    '$name survives one-shot calls through the shared module',
+    ({ create, digestSize, oneShot, wasmOneShot }) => {
+      const message = input(1025)
+      const state = create()
+      state.update(message.subarray(0, 136))
+
+      expect(wasmOneShot(input(2049))).toEqual(oneShot(input(2049)))
+
+      state.update(message.subarray(136))
+      expect(digest(state, digestSize)).toEqual(oneShot(message))
+    },
+  )
+
+  test.each(incrementalCases())(
+    '$name consumes and clears its lifecycle',
+    ({ create, digestSize, oneShot }) => {
+      const message = input(72)
+      const state = create()
+      state.update(message)
+      const output = new Uint8Array(digestSize + 7).fill(0xa5)
+      state.digestInto(output)
+
+      expect(output.subarray(0, digestSize)).toEqual(oneShot(message))
+      expect(output.subarray(digestSize)).toEqual(new Uint8Array(7).fill(0xa5))
+      expect(() => state.update(message)).toThrow('destroyed')
+      expect(() => state.clone()).toThrow('destroyed')
+      expect(() => state.digestInto(output)).toThrow('destroyed')
+      expect(() => state.destroy()).not.toThrow()
+    },
+  )
+
   test('behavior: known vectors', () => {
     expect(Bytes.toHex(engine.blake3(new Uint8Array(0)))).toBe(
       '0xaf1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262',
@@ -134,6 +309,34 @@ describe('Hash', () => {
     )
   })
 
+  test('behavior: incremental blake3 clears every WASM workspace', async () => {
+    const module = await internal.instantiate<
+      blake3_internal.Exports & blake3_internal.StateExports
+    >(blake3WasmBase64)
+    const initEnd = align8(module.heapBase) + blake3StateSize
+    module.view().fill(0xa5, module.heapBase, initEnd)
+    const state = blake3_internal.create(module)
+    expect(module.view().slice(module.heapBase, initEnd)).toEqual(
+      new Uint8Array(initEnd - module.heapBase),
+    )
+
+    const message = input(1025)
+    const updateEnd = align8(module.heapBase + message.length) + blake3StateSize
+    state.update(message)
+    expect(module.view().slice(module.heapBase, updateEnd)).toEqual(
+      new Uint8Array(updateEnd - module.heapBase),
+    )
+
+    const output = new Uint8Array(32)
+    const finalizeEnd =
+      align8(module.heapBase) + blake3StateSize + output.length
+    state.digestInto(output)
+    expect(output).toEqual(blake3(message))
+    expect(module.view().slice(module.heapBase, finalizeEnd)).toEqual(
+      new Uint8Array(finalizeEnd - module.heapBase),
+    )
+  })
+
   test('behavior: blake3 clears its complete region after a late trap', async () => {
     const module =
       await internal.instantiate<blake3_internal.Exports>(blake3WasmBase64)
@@ -215,6 +418,35 @@ describe('Hash', () => {
     )
   })
 
+  test('behavior: incremental hmacSha256 clears every WASM workspace', async () => {
+    const module =
+      await internal.instantiate<hashes_internal.Exports>(wasmBase64)
+    const key = input(100)
+    const initEnd = align8(module.heapBase + key.length) + hmacSha256StateSize
+    module.view().fill(0xa5, module.heapBase, initEnd)
+    const state = hash.createHmacSha256(module, key)
+    expect(module.view().slice(module.heapBase, initEnd)).toEqual(
+      new Uint8Array(initEnd - module.heapBase),
+    )
+
+    const message = input(137)
+    const updateEnd =
+      align8(module.heapBase + message.length) + hmacSha256StateSize
+    state.update(message)
+    expect(module.view().slice(module.heapBase, updateEnd)).toEqual(
+      new Uint8Array(updateEnd - module.heapBase),
+    )
+
+    const output = new Uint8Array(32)
+    const finalizeEnd =
+      align8(module.heapBase) + hmacSha256StateSize + output.length
+    state.digestInto(output)
+    expect(output).toEqual(hmac(sha256, key, message))
+    expect(module.view().slice(module.heapBase, finalizeEnd)).toEqual(
+      new Uint8Array(finalizeEnd - module.heapBase),
+    )
+  })
+
   test('behavior: hmacSha256 clears its complete region after a trap', async () => {
     const module = await internal.instantiate<hash.Exports>(wasmBase64)
     const key = input(120)
@@ -264,6 +496,23 @@ describe('Hash', () => {
     )
   })
 
+  test('behavior: streams a large total input through bounded memory', async () => {
+    const module =
+      await internal.instantiate<hashes_internal.Exports>(wasmBase64)
+    const state = hashes_internal.create(module, 'sha256')
+    const expected = sha256.create()
+    const chunk = input(64 * 1024)
+    const memorySize = module.view().length
+
+    for (let index = 0; index < 1024; index++) {
+      state.update(chunk)
+      expected.update(chunk)
+    }
+
+    expect(module.view().length).toBe(memorySize)
+    expect(digest(state, 32)).toEqual(expected.digest())
+  }, 60_000)
+
   test('behavior: consecutive calls do not corrupt each other', () => {
     const a = input(200)
     const b = input(7)
@@ -292,8 +541,8 @@ describe('Engine.install', () => {
   test('behavior: ox uses the WASM implementation once installed', async () => {
     await Engine.install({ Hash: engine })
     try {
-      expect(Engine.get().Hash?.blake3?.(Bytes.from('0xdeadbeef'))).toEqual(
-        blake3(Bytes.from('0xdeadbeef')),
+      expect(Hash.blake3('0xdeadbeef')).toBe(
+        '0x53147f3ce49ed4f60dfa5b9654c36ba6103c11f5737df3dabd4cbd296c4161bd',
       )
       expect(Hash.keccak256('0xdeadbeef')).toBe(
         '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1',