ox 1.0.5 → 1.1.2

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

@@ -0,0 +1,102 @@
+import { Engine as CoreEngine } from 'ox'
+import { Engine, Hash } from 'ox/node'
+import { describe, expect, test } from 'vp/test'
+
+describe('engine', () => {
+  test('behavior: does not install', async () => {
+    const engine = await Engine.engine()
+
+    expect(Object.keys(engine)).toMatchInlineSnapshot(`
+      [
+        "Ed25519",
+        "Hash",
+        "Keystore",
+        "Mnemonic",
+        "P256",
+        "X25519",
+      ]
+    `)
+    expect(Engine.get()).toMatchInlineSnapshot('{}')
+  })
+
+  test('behavior: installs for the duration of a call', async () => {
+    const node = await Engine.engine()
+    const digest = Engine.with(node, () => Hash.sha256('0xdeadbeef'))
+
+    expect(digest).toMatchInlineSnapshot(
+      `"0x5f78c33274e43fa9de5659265c1d917e25c03722dcb0b8d27db8d5feaa813953"`,
+    )
+    expect(CoreEngine.get()).toMatchInlineSnapshot('{}')
+  })
+})
+
+describe('install', () => {
+  test('behavior: installs and returns what it installed', async () => {
+    const engine = await Engine.install()
+
+    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.install()
+
+    expect(Hash.keccak256('0xdeadbeef')).toMatchInlineSnapshot(
+      `"0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1"`,
+    )
+  })
+
+  test('behavior: merges with later engines', async () => {
+    await Engine.install()
+    Engine.set({ Bls: { randomSecretKey: () => new Uint8Array(32) } })
+
+    expect(Object.keys(Engine.get()).sort()).toMatchInlineSnapshot(`
+      [
+        "Bls",
+        "Ed25519",
+        "Hash",
+        "Keystore",
+        "Mnemonic",
+        "P256",
+        "X25519",
+      ]
+    `)
+  })
+})

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

@@ -0,0 +1,32 @@
+import { Hash as NodeHash } from 'ox/node'
+import { expectTypeOf, test } from 'vp/test'
+import type * as CoreEngine from '../../core/Engine.js'
+import * as CoreHash from '../../core/Hash.js'
+
+type Slot = Awaited<ReturnType<typeof NodeHash.engine>>
+
+test('every implemented primitive is present', () => {
+  expectTypeOf<Slot['hmacSha256']>().toEqualTypeOf<
+    (key: Uint8Array, message: Uint8Array) => Uint8Array
+  >()
+  expectTypeOf<Slot['ripemd160']>().toEqualTypeOf<
+    (input: Uint8Array) => Uint8Array
+  >()
+  expectTypeOf<Slot['sha256']>().toEqualTypeOf<
+    (input: Uint8Array) => Uint8Array
+  >()
+})
+
+test('unsupported primitives are absent', () => {
+  expectTypeOf<Slot>().not.toHaveProperty('blake3')
+  expectTypeOf<Slot>().not.toHaveProperty('keccak256')
+})
+
+test('the result is the raw slot, so `Engine.install` accepts it', () => {
+  expectTypeOf<{ Hash: Slot }>().toExtend<CoreEngine.Engine>()
+})
+
+test('the Node namespace exposes the public Hash API', () => {
+  expectTypeOf(NodeHash.sha256).toEqualTypeOf(CoreHash.sha256)
+  expectTypeOf<typeof NodeHash>().not.toHaveProperty('create')
+})

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

@@ -0,0 +1,101 @@
+import { Hash as CoreHash, Hex } from 'ox'
+import { Hash } from 'ox/node'
+import { describe, expect, test } from 'vp/test'
+
+describe('engine', () => {
+  test('behavior: exposes the supported primitives', async () => {
+    const engine = await Hash.engine()
+
+    expect(Object.keys(engine).sort()).toMatchInlineSnapshot(`
+      [
+        "hmacSha256",
+        "ripemd160",
+        "sha256",
+      ]
+    `)
+  })
+
+  test('behavior: matches published empty-input vectors', async () => {
+    const { hmacSha256, ripemd160, sha256 } = await Hash.engine()
+    const empty = new Uint8Array()
+
+    expect(Hex.fromBytes(sha256(empty))).toMatchInlineSnapshot(
+      `"0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"`,
+    )
+    expect(Hex.fromBytes(ripemd160(empty))).toMatchInlineSnapshot(
+      `"0x9c1185a5c5e9fc54612808977ee8f548b2258d31"`,
+    )
+    expect(Hex.fromBytes(hmacSha256(empty, empty))).toMatchInlineSnapshot(
+      `"0xb613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad"`,
+    )
+  })
+
+  test('behavior: agrees with the default across block boundaries', async () => {
+    const node = await Hash.engine()
+
+    for (const size of [0, 1, 55, 56, 63, 64, 65, 127, 128, 129]) {
+      const input = Uint8Array.from({ length: size }, (_, index) => index % 251)
+      expect(node.sha256(input)).toEqual(
+        CoreHash.sha256(input, { as: 'Bytes' }),
+      )
+      expect(node.ripemd160(input)).toEqual(
+        CoreHash.ripemd160(input, { as: 'Bytes' }),
+      )
+    }
+  })
+
+  test('behavior: agrees with the default across HMAC key sizes', async () => {
+    const { hmacSha256 } = await Hash.engine()
+    const message = Uint8Array.from({ length: 65 }, (_, index) => index % 251)
+
+    for (const size of [0, 1, 32, 63, 64, 65, 200]) {
+      const key = Uint8Array.from({ length: size }, (_, index) => index % 239)
+      expect(hmacSha256(key, message)).toEqual(
+        CoreHash.hmac256(key, message, { as: 'Bytes' }),
+      )
+    }
+  })
+
+  test('behavior: respects typed-array offsets', async () => {
+    const node = await Hash.engine()
+    const input = Uint8Array.from(
+      { length: 80 },
+      (_, index) => (index * 17) % 251,
+    ).subarray(7, 71)
+    const key = Uint8Array.from(
+      { length: 48 },
+      (_, index) => (index * 29) % 239,
+    ).subarray(5, 37)
+
+    expect(node.sha256(input)).toEqual(CoreHash.sha256(input, { as: 'Bytes' }))
+    expect(node.ripemd160(input)).toEqual(
+      CoreHash.ripemd160(input, { as: 'Bytes' }),
+    )
+    expect(node.hmacSha256(key, input)).toEqual(
+      CoreHash.hmac256(key, input, { as: 'Bytes' }),
+    )
+  })
+
+  test('behavior: returns a fresh engine', async () => {
+    const first = await Hash.engine()
+    const second = await Hash.engine()
+
+    expect(first === second).toMatchInlineSnapshot('false')
+  })
+
+  test('behavior: returns owned Uint8Array values', async () => {
+    const { hmacSha256, ripemd160, sha256 } = await Hash.engine()
+    const input = Uint8Array.of(1, 2, 3)
+    const outputs = [hmacSha256(input, input), ripemd160(input), sha256(input)]
+
+    expect(outputs.map((output) => output.constructor === Uint8Array))
+      .toMatchInlineSnapshot(`
+      [
+        true,
+        true,
+        true,
+      ]
+    `)
+    expect(sha256(input) === sha256(input)).toMatchInlineSnapshot('false')
+  })
+})

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

@@ -0,0 +1,58 @@
+import { ctr } from '@noble/ciphers/aes.js'
+import { pbkdf2 } from '@noble/hashes/pbkdf2.js'
+import { sha256 } from '@noble/hashes/sha2.js'
+import { fc, test } from '@fast-check/vitest'
+import { expect } from 'vp/test'
+import { numRuns } from '../../../test/fuzz/numRuns.js'
+import * as Keystore from '../Keystore.js'
+
+const subview = (bytes: Uint8Array) => {
+  const value = new Uint8Array(bytes.length + 4)
+  value.set(bytes, 2)
+  return value.subarray(2, bytes.length + 2)
+}
+
+const arbitraryKey = fc
+  .oneof(
+    fc.uint8Array({ maxLength: 16, minLength: 16 }),
+    fc.uint8Array({ maxLength: 24, minLength: 24 }),
+    fc.uint8Array({ maxLength: 32, minLength: 32 }),
+  )
+  .map(subview)
+
+test.prop(
+  {
+    data: fc.uint8Array({ maxLength: 256 }).map(subview),
+    iv: fc.uint8Array({ maxLength: 16, minLength: 16 }).map(subview),
+    key: arbitraryKey,
+  },
+  { numRuns },
+)('Node AES-CTR agrees with the default', async ({ data, iv, key }) => {
+  const { aesCtrDecrypt, aesCtrEncrypt } = await Keystore.engine()
+  const expected = ctr(key, iv).encrypt(data)
+  const encrypted = aesCtrEncrypt(key, iv, data)
+
+  expect(encrypted).toEqual(expected)
+  expect(aesCtrDecrypt(key, iv, encrypted)).toEqual(data)
+})
+
+test.prop(
+  {
+    c: fc.integer({ max: 32, min: 1 }),
+    dkLen: fc.integer({ max: 96, min: 1 }),
+    password: fc.uint8Array({ maxLength: 96 }).map(subview),
+    salt: fc.uint8Array({ maxLength: 96 }).map(subview),
+  },
+  { numRuns },
+)(
+  'Node PBKDF2-HMAC-SHA256 agrees with the default',
+  async ({ c, dkLen, password, salt }) => {
+    const { pbkdf2Sha256, pbkdf2Sha256Async } = await Keystore.engine()
+    const expected = pbkdf2(sha256, password, salt, { c, dkLen })
+
+    expect(pbkdf2Sha256(password, salt, { c, dkLen })).toEqual(expected)
+    expect(await pbkdf2Sha256Async(password, salt, { c, dkLen })).toEqual(
+      expected,
+    )
+  },
+)

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

@@ -0,0 +1,43 @@
+import type { Engine } from 'ox'
+import { expectTypeOf, test } from 'vp/test'
+import * as core_Keystore from '../../core/Keystore.js'
+import * as NodeKeystore from '../Keystore.js'
+
+type Slot = Awaited<ReturnType<typeof NodeKeystore.engine>>
+
+test('every implemented primitive is present', () => {
+  expectTypeOf<Slot['aesCtrDecrypt']>().toEqualTypeOf<
+    (key: Uint8Array, iv: Uint8Array, data: Uint8Array) => Uint8Array
+  >()
+  expectTypeOf<Slot['aesCtrEncrypt']>().toEqualTypeOf<
+    (key: Uint8Array, iv: Uint8Array, data: Uint8Array) => Uint8Array
+  >()
+  expectTypeOf<Slot['pbkdf2Sha256']>().toEqualTypeOf<
+    (
+      password: Uint8Array,
+      salt: Uint8Array,
+      options: { c: number; dkLen: number },
+    ) => Uint8Array
+  >()
+  expectTypeOf<Slot['pbkdf2Sha256Async']>().toEqualTypeOf<
+    (
+      password: Uint8Array,
+      salt: Uint8Array,
+      options: { c: number; dkLen: number },
+    ) => Promise<Uint8Array>
+  >()
+})
+
+test('unsupported primitives are absent', () => {
+  expectTypeOf<Slot>().not.toHaveProperty('scrypt')
+  expectTypeOf<Slot>().not.toHaveProperty('scryptAsync')
+})
+
+test('the result is the raw slot', () => {
+  expectTypeOf<{ Keystore: Slot }>().toExtend<Engine.Engine>()
+})
+
+test('the Node namespace exposes the public Keystore API', () => {
+  expectTypeOf(NodeKeystore.pbkdf2).toEqualTypeOf(core_Keystore.pbkdf2)
+  expectTypeOf<typeof NodeKeystore>().not.toHaveProperty('create')
+})

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

@@ -0,0 +1,198 @@
+import { ctr } from '@noble/ciphers/aes.js'
+import { pbkdf2 } from '@noble/hashes/pbkdf2.js'
+import { sha256 } from '@noble/hashes/sha2.js'
+import { Hex } from 'ox'
+import { describe, expect, test } from 'vp/test'
+import * as vectors from '../../../test/vectors/pbkdf2/index.js'
+import * as Keystore from '../Keystore.js'
+
+describe('engine', () => {
+  test('behavior: matches NIST SP 800-38A AES-CTR vectors', async () => {
+    const { aesCtrDecrypt, aesCtrEncrypt } = await Keystore.engine()
+    const iv = Hex.toBytes('0xf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff')
+    const plaintext = Hex.toBytes('0x6bc1bee22e409f96e93d7e117393172a')
+    const vectors = [
+      {
+        ciphertext: '0x874d6191b620e3261bef6864990db6ce',
+        key: '0x2b7e151628aed2a6abf7158809cf4f3c',
+      },
+      {
+        ciphertext: '0x1abc932417521ca24f2b0459fe7e6e0b',
+        key: '0x8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b',
+      },
+      {
+        ciphertext: '0x601ec313775789a5b7a7f504bbf3d228',
+        key: '0x603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4',
+      },
+    ] as const
+
+    expect(
+      vectors.map(({ ciphertext, key }) => {
+        const encrypted = aesCtrEncrypt(Hex.toBytes(key), iv, plaintext)
+        const decrypted = aesCtrDecrypt(
+          Hex.toBytes(key),
+          iv,
+          Hex.toBytes(ciphertext),
+        )
+        return {
+          decrypted: Hex.fromBytes(decrypted),
+          encrypted: Hex.fromBytes(encrypted),
+        }
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "decrypted": "0x6bc1bee22e409f96e93d7e117393172a",
+          "encrypted": "0x874d6191b620e3261bef6864990db6ce",
+        },
+        {
+          "decrypted": "0x6bc1bee22e409f96e93d7e117393172a",
+          "encrypted": "0x1abc932417521ca24f2b0459fe7e6e0b",
+        },
+        {
+          "decrypted": "0x6bc1bee22e409f96e93d7e117393172a",
+          "encrypted": "0x601ec313775789a5b7a7f504bbf3d228",
+        },
+      ]
+    `)
+  })
+
+  test('behavior: matches RFC 7914 PBKDF2-HMAC-SHA256 vectors', async () => {
+    const { pbkdf2Sha256 } = await Keystore.engine()
+
+    for (const { iterations, key, password, salt } of vectors.vectors)
+      expect(
+        pbkdf2Sha256(password, salt, {
+          c: iterations,
+          dkLen: key.length,
+        }),
+      ).toEqual(key)
+  })
+
+  test('behavior: agrees with the defaults across boundary sizes', async () => {
+    const node = await Keystore.engine()
+    const iv = Uint8Array.from(
+      { length: 20 },
+      (_, index) => (index * 13) % 251,
+    ).subarray(2, 18)
+
+    for (const keySize of [16, 24, 32]) {
+      const key = Uint8Array.from(
+        { length: keySize + 4 },
+        (_, index) => (index * 17) % 251,
+      ).subarray(2, keySize + 2)
+
+      for (const size of [0, 1, 15, 16, 17, 31, 32, 33]) {
+        const data = Uint8Array.from(
+          { length: size + 6 },
+          (_, index) => (index * 29) % 251,
+        ).subarray(3, size + 3)
+        const encrypted = node.aesCtrEncrypt(key, iv, data)
+
+        expect(encrypted).toEqual(ctr(key, iv).encrypt(data))
+        expect(node.aesCtrDecrypt(key, iv, encrypted)).toEqual(data)
+      }
+    }
+
+    const password = Uint8Array.from(
+      { length: 37 },
+      (_, index) => (index * 31) % 251,
+    ).subarray(3, 34)
+    const salt = Uint8Array.from(
+      { length: 41 },
+      (_, index) => (index * 37) % 251,
+    ).subarray(5, 37)
+
+    for (const options of [
+      { c: 1, dkLen: 1 },
+      { c: 2, dkLen: 31 },
+      { c: 3, dkLen: 32 },
+      { c: 4, dkLen: 33 },
+      { c: 16, dkLen: 64 },
+    ]) {
+      const expected = pbkdf2(sha256, password, salt, options)
+      expect(node.pbkdf2Sha256(password, salt, options)).toEqual(expected)
+      expect(await node.pbkdf2Sha256Async(password, salt, options)).toEqual(
+        expected,
+      )
+    }
+  })
+
+  test('behavior: does not mutate inputs and returns owned arrays', async () => {
+    const node = await Keystore.engine()
+    const data = Uint8Array.of(1, 2, 3, 4, 5)
+    const iv = new Uint8Array(16).fill(2)
+    const key = new Uint8Array(16).fill(3)
+    const password = Uint8Array.of(4, 5, 6)
+    const salt = Uint8Array.of(7, 8, 9)
+    const inputs = [data, iv, key, password, salt]
+    const before = inputs.map((input) => input.slice())
+
+    const outputs = [
+      node.aesCtrEncrypt(key, iv, data),
+      node.aesCtrDecrypt(key, iv, data),
+      node.pbkdf2Sha256(password, salt, { c: 1, dkLen: 32 }),
+      await node.pbkdf2Sha256Async(password, salt, { c: 1, dkLen: 32 }),
+    ]
+
+    expect(inputs).toEqual(before)
+    expect(outputs.map((output) => output.constructor === Uint8Array))
+      .toMatchInlineSnapshot(`
+        [
+          true,
+          true,
+          true,
+          true,
+        ]
+      `)
+    expect(
+      node.aesCtrEncrypt(key, iv, data) === node.aesCtrEncrypt(key, iv, data),
+    ).toMatchInlineSnapshot('false')
+  })
+
+  test('behavior: rejects malformed AES and PBKDF2 parameters', async () => {
+    const node = await Keystore.engine()
+    const data = new Uint8Array()
+    const iv = new Uint8Array(16)
+    const key = new Uint8Array(16)
+
+    for (const keyLength of [0, 15, 17, 23, 25, 31, 33]) {
+      expect(() => ctr(new Uint8Array(keyLength), iv).encrypt(data)).toThrow()
+      expect(() =>
+        node.aesCtrEncrypt(new Uint8Array(keyLength), iv, data),
+      ).toThrow()
+      expect(() =>
+        node.aesCtrDecrypt(new Uint8Array(keyLength), iv, data),
+      ).toThrow()
+    }
+    for (const ivLength of [0, 15, 17]) {
+      expect(() => ctr(key, new Uint8Array(ivLength)).encrypt(data)).toThrow()
+      expect(() =>
+        node.aesCtrEncrypt(key, new Uint8Array(ivLength), data),
+      ).toThrow()
+      expect(() =>
+        node.aesCtrDecrypt(key, new Uint8Array(ivLength), data),
+      ).toThrow()
+    }
+
+    for (const options of [
+      { c: 0, dkLen: 32 },
+      { c: 1.5, dkLen: 32 },
+      { c: 1, dkLen: 0 },
+      { c: 1, dkLen: 1.5 },
+    ]) {
+      expect(() => pbkdf2(sha256, data, data, options)).toThrow()
+      expect(() => node.pbkdf2Sha256(data, data, options)).toThrow()
+      await expect(
+        node.pbkdf2Sha256Async(data, data, options),
+      ).rejects.toThrow()
+    }
+  })
+
+  test('behavior: returns a fresh engine', async () => {
+    const first = await Keystore.engine()
+    const second = await Keystore.engine()
+
+    expect(first === second).toMatchInlineSnapshot('false')
+  })
+})

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

@@ -0,0 +1,31 @@
+import { mnemonicToSeedSync } from '@scure/bip39'
+import { fc, test } from '@fast-check/vitest'
+import { expect } from 'vp/test'
+import { numRuns } from '../../../test/fuzz/numRuns.js'
+import * as Mnemonic from '../Mnemonic.js'
+
+const arbitraryWord = fc.oneof(
+  fc
+    .string({ maxLength: 16, minLength: 1 })
+    .filter((value) => !value.normalize('NFKD').includes(' ')),
+  fc.constantFrom('café', 'cafe\u0301', 'あおぞら', '㍍ガバヴァ'),
+)
+
+test.prop(
+  {
+    mnemonic: fc
+      .array(arbitraryWord, { maxLength: 12, minLength: 12 })
+      .map((words) => words.join(' ')),
+    passphrase: fc.string({ maxLength: 32 }),
+  },
+  { numRuns },
+)(
+  'Node BIP-39 seed derivation agrees with the default',
+  async ({ mnemonic, passphrase }) => {
+    const { toSeed } = await Mnemonic.engine()
+
+    expect(toSeed(mnemonic, passphrase)).toEqual(
+      mnemonicToSeedSync(mnemonic, passphrase),
+    )
+  },
+)

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

@@ -0,0 +1,21 @@
+import { expectTypeOf, test } from 'vp/test'
+import type * as Engine from '../../core/Engine.js'
+import * as core_Mnemonic from '../../core/Mnemonic.js'
+import * as NodeMnemonic from '../Mnemonic.js'
+
+type Slot = Awaited<ReturnType<typeof NodeMnemonic.engine>>
+
+test('every implemented primitive is present', () => {
+  expectTypeOf<Slot['toSeed']>().toEqualTypeOf<
+    (mnemonic: string, passphrase?: string) => Uint8Array
+  >()
+})
+
+test('the result is the raw slot', () => {
+  expectTypeOf<{ Mnemonic: Slot }>().toExtend<Engine.Engine>()
+})
+
+test('the Node namespace exposes the public Mnemonic API', () => {
+  expectTypeOf(NodeMnemonic.toSeed).toEqualTypeOf(core_Mnemonic.toSeed)
+  expectTypeOf<typeof NodeMnemonic>().not.toHaveProperty('create')
+})