ox 1.1.2 → 1.3.0

package/src/core/_test/Secp256k1.test.ts

@@ -1,4 +1,4 @@
-import { Address, Bytes, Hex, PublicKey, Secp256k1 } from 'ox'
+import { Address, Bytes, Engine, Hex, PublicKey, Secp256k1 } from 'ox'
 import { describe, expect, test } from 'vp/test'
 import { accounts } from '../../../test/constants/accounts.js'
 
@@ -123,6 +123,94 @@ describe('createKeyPair', () => {
   })
 })
 
+describe('fromPrf', () => {
+  test.each([
+    {
+      privateKey:
+        '0xd23e6d2bbfdc109c1d4706bc3a78a32356682a4e6ef09c3bbeabf5460235de36',
+      prf: '0x0000000000000000000000000000000000000000000000000000000000000000',
+    },
+    {
+      privateKey:
+        '0xcf0eab798d92f274ee2b9b6f3397186cdd3a08b09c77b7313fb1abf529611bc5',
+      prf: '0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f',
+    },
+  ] as const)('vector: $prf', ({ privateKey, prf }) => {
+    expect(Secp256k1.fromPrf(prf)).toBe(privateKey)
+  })
+
+  test('value: Bytes', () => {
+    const prf = Bytes.fromHex(
+      '0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f',
+    )
+    expect(Secp256k1.fromPrf(prf)).toMatchInlineSnapshot(
+      `"0xcf0eab798d92f274ee2b9b6f3397186cdd3a08b09c77b7313fb1abf529611bc5"`,
+    )
+  })
+
+  test('options: as', () => {
+    const privateKey = Secp256k1.fromPrf(
+      '0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f',
+      { as: 'Bytes' },
+    )
+    expect(privateKey).toEqual(
+      Bytes.fromHex(
+        '0xcf0eab798d92f274ee2b9b6f3397186cdd3a08b09c77b7313fb1abf529611bc5',
+      ),
+    )
+  })
+
+  test('behavior: output is a valid secp256k1 private key', () => {
+    const privateKey = Secp256k1.fromPrf(Bytes.random(32), { as: 'Bytes' })
+    expect(Secp256k1.noble.utils.isValidSecretKey(privateKey)).toBe(true)
+  })
+
+  test('behavior: skips invalid scalar candidates', () => {
+    const messages: Hex.Hex[] = []
+    const privateKey = Engine.with(
+      {
+        Hash: {
+          hmacSha256: (_key, message) => {
+            messages.push(Hex.fromBytes(message))
+            if (messages.length === 1) return new Uint8Array(32)
+            return Bytes.fromHex(
+              '0xef3f982137910a4c362017e69ba173fbb342325802ec827767aa6942027af35b',
+            )
+          },
+        },
+      },
+      () =>
+        Secp256k1.fromPrf(
+          '0x0000000000000000000000000000000000000000000000000000000000000000',
+        ),
+    )
+
+    expect(privateKey).toBe(
+      '0xef3f982137910a4c362017e69ba173fbb342325802ec827767aa6942027af35b',
+    )
+    expect(messages).toMatchInlineSnapshot(`
+      [
+        "0x6f782e736563703235366b312e66726f6d5072662e763100000000",
+        "0x6f782e736563703235366b312e66726f6d5072662e763100000001",
+      ]
+    `)
+  })
+
+  test('error: PRF output is too short', () => {
+    expect(() => Secp256k1.fromPrf(new Uint8Array(31)))
+      .toThrowErrorMatchingInlineSnapshot(`
+        [Secp256k1.InvalidPrfSizeError: PRF output must be exactly 32 bytes. Received 31 bytes.]
+      `)
+  })
+
+  test('error: PRF output is too long', () => {
+    expect(() => Secp256k1.fromPrf(new Uint8Array(33)))
+      .toThrowErrorMatchingInlineSnapshot(`
+        [Secp256k1.InvalidPrfSizeError: PRF output must be exactly 32 bytes. Received 33 bytes.]
+      `)
+  })
+})
+
 describe('getSharedSecret', () => {
   test('default', () => {
     const privateKeyA = accounts[0].privateKey
@@ -483,6 +571,7 @@ test('exports', () => {
     [
       "noble",
       "createKeyPair",
+      "fromPrf",
       "getPublicKey",
       "getSharedSecret",
       "randomPrivateKey",
@@ -490,6 +579,7 @@ test('exports', () => {
       "recoverPublicKey",
       "sign",
       "verify",
+      "InvalidPrfSizeError",
     ]
   `)
 })

package/src/core/_test/Transaction.test.ts

@@ -158,7 +158,11 @@ describe('fromRpc', () => {
         })
         .then(Transaction.fromRpc)
 
-      expect(transaction).toMatchInlineSnapshot(`
+      const { blockTimestamp: _, ...transaction_ } = {
+        blockTimestamp: undefined,
+        ...transaction,
+      }
+      expect(transaction_).toMatchInlineSnapshot(`
         {
           "blockHash": "0x8299a290ae51a8958965987e2caf178a09b8ecde01b737b5f9a8badbacb407cb",
           "blockNumber": 1110749n,
@@ -411,7 +415,12 @@ describe('fromRpc', () => {
           ],
         })
         .then(Transaction.fromRpc)
-      expect(transaction).toMatchInlineSnapshot(`
+
+      const { blockTimestamp: _, ...transaction_ } = {
+        blockTimestamp: undefined,
+        ...transaction,
+      }
+      expect(transaction_).toMatchInlineSnapshot(`
         {
           "accessList": [],
           "blockHash": "0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b",

package/src/core/_test/WebAuthn.test-d.ts

@@ -0,0 +1,142 @@
+import {
+  type Bytes,
+  type Hex,
+  Secp256k1,
+  WebAuthn,
+  type WebAuthnP256,
+} from 'ox'
+import { describe, expectTypeOf, test } from 'vp/test'
+
+declare const input: Bytes.Bytes
+
+describe('createCredential', () => {
+  test('behavior: returns required PRF output when requested', () => {
+    const infer = async () => {
+      const credential = await WebAuthn.createCredential({
+        name: 'Example',
+        prf: true,
+      })
+
+      expectTypeOf(credential.prf).toEqualTypeOf<Bytes.Bytes>()
+      expectTypeOf(Secp256k1.fromPrf(credential.prf)).toEqualTypeOf<Hex.Hex>()
+    }
+    expectTypeOf(infer).toBeFunction()
+  })
+
+  test('behavior: preserves ordinary credential return type', () => {
+    const infer = async () => {
+      const credential = await WebAuthn.createCredential({
+        name: 'Example',
+      })
+
+      expectTypeOf(credential).toEqualTypeOf<WebAuthnP256.P256Credential>()
+      // @ts-expect-error Ordinary credential creation has no PRF output.
+      void credential.prf
+    }
+    expectTypeOf(infer).toBeFunction()
+  })
+
+  test('behavior: accepts custom input', () => {
+    const infer = async () => {
+      const credential = await WebAuthn.createCredential({
+        name: 'Example',
+        prf: {
+          input,
+        },
+      })
+
+      expectTypeOf(credential.prf).toEqualTypeOf<Bytes.Bytes>()
+    }
+    expectTypeOf(infer).toBeFunction()
+  })
+
+  test('error: managed options', () => {
+    const managedExtension = () =>
+      // @ts-expect-error The PRF extension is managed by createCredential.
+      WebAuthn.createCredential({
+        extensions: {
+          prf: {
+            eval: {
+              first: input,
+            },
+          },
+        },
+        name: 'Example',
+        prf: true,
+      })
+
+    const userVerification = () =>
+      WebAuthn.createCredential({
+        authenticatorSelection: {
+          // @ts-expect-error User verification is always required.
+          userVerification: 'preferred',
+        },
+        name: 'Example',
+        prf: true,
+      })
+
+    const rawOptions = {
+      name: 'Example',
+      prf: true,
+      publicKey: {},
+    } as const
+    const publicKey = () =>
+      // @ts-expect-error Raw credential options cannot be combined with PRF.
+      WebAuthn.createCredential(rawOptions)
+
+    expectTypeOf(managedExtension).toBeFunction()
+    expectTypeOf(publicKey).toBeFunction()
+    expectTypeOf(userVerification).toBeFunction()
+  })
+})
+
+describe('getCredential', () => {
+  test('behavior: returns required PRF output', () => {
+    const infer = async () => {
+      const credential = await WebAuthn.getCredential({
+        prf: true,
+      })
+
+      expectTypeOf(credential.prf).toEqualTypeOf<Bytes.Bytes>()
+      expectTypeOf(credential.id).toEqualTypeOf<string>()
+      expectTypeOf(credential.raw).toEqualTypeOf<WebAuthn.PublicKeyCredential>()
+      // @ts-expect-error PRF requests do not parse the assertion signature.
+      void credential.signature
+    }
+    expectTypeOf(infer).toBeFunction()
+  })
+
+  test('error: managed options', () => {
+    const managedExtension = () =>
+      WebAuthn.getCredential({
+        extensions: {
+          // @ts-expect-error The PRF extension is managed by getCredential.
+          prf: {
+            eval: {
+              first: input,
+            },
+          },
+        },
+        prf: true,
+      })
+
+    const userVerification = () =>
+      WebAuthn.getCredential({
+        prf: true,
+        // @ts-expect-error User verification is always required.
+        userVerification: 'preferred',
+      })
+
+    const rawOptions = {
+      prf: true,
+      publicKey: {},
+    } as const
+    const publicKey = () =>
+      // @ts-expect-error Raw credential options cannot be combined with PRF.
+      WebAuthn.getCredential(rawOptions)
+
+    expectTypeOf(managedExtension).toBeFunction()
+    expectTypeOf(publicKey).toBeFunction()
+    expectTypeOf(userVerification).toBeFunction()
+  })
+})