ox 1.1.2 → 1.3.0

package/src/core/WebAuthnP256.ts

@@ -16,9 +16,9 @@ export const createChallenge = Registration.createChallenge
  *
  * @example
  * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  *
- * const credential = await WebAuthnP256.createCredential({
+ * const credential = await WebAuthn.createCredential({
  *   name: 'Example'
  * }) // [!code focus]
  * // @log: {
@@ -27,7 +27,7 @@ export const createChallenge = Registration.createChallenge
  * // @log:   raw: PublicKeyCredential {},
  * // @log: }
  *
- * const { metadata, signature } = await WebAuthnP256.sign({
+ * const { metadata, signature } = await WebAuthn.sign({
  *   credentialId: credential.id,
  *   challenge: '0xdeadbeef'
  * })
@@ -49,27 +49,25 @@ export declare namespace createCredential {
 
 /**
  * Gets the authenticator data which contains information about the
- * processing of an authenticator request (ie. from `WebAuthnP256.sign`).
+ * processing of an authenticator request (ie. from `WebAuthn.sign`).
  *
  * :::warning
  *
  * This function is mainly for testing purposes or for manually constructing
  * autenticator data. In most cases you will not need this function.
  * `authenticatorData` is typically returned as part of the
- * {@link ox#WebAuthnP256.(sign:function)} response (ie. an authenticator response).
+ * {@link ox#WebAuthn.(sign:function)} response (ie. an authenticator response).
  *
  * :::
  *
  * @example
  * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  *
- * const authenticatorData = WebAuthnP256.getAuthenticatorData(
- *   {
- *     rpId: 'example.com',
- *     signCount: 420
- *   }
- * )
+ * const authenticatorData = WebAuthn.getAuthenticatorData({
+ *   rpId: 'example.com',
+ *   signCount: 420
+ * })
  * // @log: "0xa379a6f6eeafb9a55e378c118034e2751e682fab9f2d30ab13d2125586ce194705000001a4"
  * ```
  *
@@ -79,20 +77,18 @@ export declare namespace createCredential {
  * Include a credential ID and public key in the authenticator data (for registration responses):
  *
  * ```ts twoslash
- * import { P256, WebAuthnP256 } from 'ox'
+ * import { P256, WebAuthn } from 'ox'
  *
  * const { publicKey } = P256.createKeyPair()
  *
- * const authenticatorData = WebAuthnP256.getAuthenticatorData(
- *   {
- *     rpId: 'example.com',
- *     flag: 0x41, // UP + AT
- *     credential: {
- *       id: new Uint8Array(32),
- *       publicKey
- *     }
+ * const authenticatorData = WebAuthn.getAuthenticatorData({
+ *   rpId: 'example.com',
+ *   flag: 0x41, // UP + AT
+ *   credential: {
+ *     id: new Uint8Array(32),
+ *     publicKey
  *   }
- * )
+ * })
  * ```
  *
  * @param options - Options to construct the authenticator data.
@@ -108,22 +104,22 @@ export declare namespace getAuthenticatorData {
 
 /**
  * Constructs the Client Data in stringified JSON format which represents client data that
- * was passed to `credentials.get()` in {@link ox#WebAuthnP256.(sign:function)}.
+ * was passed to `credentials.get()` in {@link ox#WebAuthn.(sign:function)}.
  *
  * :::warning
  *
  * This function is mainly for testing purposes or for manually constructing
  * client data. In most cases you will not need this function.
  * `clientDataJSON` is typically returned as part of the
- * {@link ox#WebAuthnP256.(sign:function)} response (ie. an authenticator response).
+ * {@link ox#WebAuthn.(sign:function)} response (ie. an authenticator response).
  *
  * :::
  *
  * @example
  * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  *
- * const clientDataJSON = WebAuthnP256.getClientDataJSON({
+ * const clientDataJSON = WebAuthn.getClientDataJSON({
  *   challenge: '0xdeadbeef',
  *   origin: 'https://example.com'
  * })
@@ -154,19 +150,17 @@ export declare namespace getClientDataJSON {
  *
  * @example
  * ```ts twoslash
- * import { P256, WebAuthnP256 } from 'ox'
+ * import { P256, WebAuthn } from 'ox'
  *
  * const { publicKey } = P256.createKeyPair()
  *
- * const attestationObject = WebAuthnP256.getAttestationObject(
- *   {
- *     authData: WebAuthnP256.getAuthenticatorData({
- *       rpId: 'example.com',
- *       flag: 0x41,
- *       credential: { id: new Uint8Array(32), publicKey }
- *     })
- *   }
- * )
+ * const attestationObject = WebAuthn.getAttestationObject({
+ *   authData: WebAuthn.getAuthenticatorData({
+ *     rpId: 'example.com',
+ *     flag: 0x41,
+ *     credential: { id: new Uint8Array(32), publicKey }
+ *   })
+ * })
  * ```
  *
  * @param options - Options to construct the attestation object.
@@ -186,9 +180,9 @@ export declare namespace getAttestationObject {
  *
  * @example
  * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  *
- * const options = WebAuthnP256.getCredentialCreationOptions({
+ * const options = WebAuthn.getCredentialCreationOptions({
  *   name: 'Example'
  * })
  *
@@ -212,9 +206,9 @@ export declare namespace getCredentialCreationOptions {
  *
  * @example
  * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  *
- * const options = WebAuthnP256.getCredentialRequestOptions({
+ * const options = WebAuthn.getCredentialRequestOptions({
  *   challenge: '0xdeadbeef'
  * })
  *
@@ -242,15 +236,15 @@ export declare namespace getCredentialRequestOptions {
  *
  * This function is mainly for testing purposes or for manually constructing
  * signing payloads. In most cases you will not need this function and
- * instead use {@link ox#WebAuthnP256.(sign:function)}.
+ * instead use {@link ox#WebAuthn.(sign:function)}.
  *
  * :::
  *
  * @example
  * ```ts twoslash
- * import { WebAuthnP256, WebCryptoP256 } from 'ox'
+ * import { WebAuthn, WebCryptoP256 } from 'ox'
  *
- * const { metadata, payload } = WebAuthnP256.getSignPayload({
+ * const { metadata, payload } = WebAuthn.getSignPayload({
  *   // [!code focus]
  *   challenge: '0xdeadbeef' // [!code focus]
  * }) // [!code focus]
@@ -294,13 +288,13 @@ export declare namespace getSignPayload {
  *
  * @example
  * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  *
- * const credential = await WebAuthnP256.createCredential({
+ * const credential = await WebAuthn.createCredential({
  *   name: 'Example'
  * })
  *
- * const { metadata, signature } = await WebAuthnP256.sign({
+ * const { metadata, signature } = await WebAuthn.sign({
  *   // [!code focus]
  *   credentialId: credential.id, // [!code focus]
  *   challenge: '0xdeadbeef' // [!code focus]
@@ -337,18 +331,18 @@ export declare namespace sign {
  *
  * @example
  * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
+ * import { WebAuthn } from 'ox'
  *
- * const credential = await WebAuthnP256.createCredential({
+ * const credential = await WebAuthn.createCredential({
  *   name: 'Example'
  * })
  *
- * const { metadata, signature } = await WebAuthnP256.sign({
+ * const { metadata, signature } = await WebAuthn.sign({
  *   credentialId: credential.id,
  *   challenge: '0xdeadbeef'
  * })
  *
- * const result = await WebAuthnP256.verify({
+ * const result = await WebAuthn.verify({
  *   // [!code focus]
  *   metadata, // [!code focus]
  *   challenge: '0xdeadbeef', // [!code focus]
@@ -398,3 +392,6 @@ export type {
   ResidentKeyRequirement,
   UserVerificationRequirement,
 } from '../webauthn/Types.js'
+
+/** @deprecated Use `WebAuthn` instead. */
+declare module './WebAuthnP256.js' {}

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

@@ -218,6 +218,15 @@ describe('encodeData', () => {
     )
   })
 
+  test('behavior: malformed bytes compatibility', () => {
+    const abiFunction = AbiFunction.from('function foo(bytes)')
+    expect(
+      AbiFunction.encodeData(abiFunction, ['0xzz1']),
+    ).toMatchInlineSnapshot(
+      `"0x30c8d1da00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002zz10000000000000000000000000000000000000000000000000000000000000"`,
+    )
+  })
+
   test('behavior: with overloads', () => {
     const abi = Abi.from([
       {

package/src/core/_test/AbiParameters.differential.fuzz.ts

@@ -0,0 +1,156 @@
+import { test } from '@fast-check/vitest'
+import { AbiCoder, Interface, ParamType } from 'ethers'
+import { AbiFunction, AbiParameters } from 'ox'
+import { describe, expect } from 'vp/test'
+
+import { arbitraryAbiCase } from '../../../test/fuzz/arbitraries/abi.js'
+import { numRuns } from '../../../test/fuzz/numRuns.js'
+
+const coder = AbiCoder.defaultAbiCoder()
+
+describe('AbiParameters differential', () => {
+  test.prop(
+    {
+      input: arbitraryAbiCase({
+        maxArrayLength: 4,
+        maxBytesLength: 128,
+        maxDepth: 4,
+        maxTupleArity: 4,
+        minFixedArrayLength: 0,
+      }),
+    },
+    { numRuns },
+  )('encode matches ethers AbiCoder', ({ input }) => {
+    expectParameters(input.parameters, input.values)
+  })
+
+  test('integer boundaries match ethers AbiCoder', () => {
+    for (let bits = 8; bits <= 256; bits += 8) {
+      const bits_ = BigInt(bits)
+      const maxUnsigned = 2n ** bits_ - 1n
+      const maxSigned = 2n ** (bits_ - 1n) - 1n
+      const minSigned = -(2n ** (bits_ - 1n))
+
+      for (const value of [0n, 1n, maxUnsigned])
+        expectParameters([{ type: `uint${bits}` }], [value])
+      for (const value of [minSigned, -1n, 0n, 1n, maxSigned])
+        expectParameters([{ type: `int${bits}` }], [value])
+
+      if (bits > 64) {
+        expectParameters([{ type: `uint${bits}` }], [2n ** 64n - 1n])
+        expectParameters([{ type: `uint${bits}` }], [2n ** 64n])
+      }
+    }
+  })
+
+  test('bytes and string boundaries match ethers AbiCoder', () => {
+    for (let size = 1; size <= 32; size++)
+      expectParameters([{ type: `bytes${size}` }], [`0x${'ab'.repeat(size)}`])
+
+    for (const size of [0, 1, 31, 32, 33, 63, 64, 65, 128]) {
+      expectParameters([{ type: 'bytes' }], [`0x${'ab'.repeat(size)}`])
+      expectParameters([{ type: 'string' }], ['a'.repeat(size)])
+    }
+
+    for (const value of ['\u0000', 'é', '€', '😀', 'a😀b'])
+      expectParameters([{ type: 'string' }], [value])
+  })
+
+  test('zero-width types match ethers AbiCoder', () => {
+    expectParameters([{ type: 'uint256[0]' }, { type: 'uint256' }], [[], 3n])
+    expectParameters([{ type: 'string[0]' }, { type: 'uint256' }], [[], 3n])
+    expectParameters([{ type: 'tuple', components: [] }], [[]])
+  })
+})
+
+describe('AbiFunction differential', () => {
+  test.prop(
+    {
+      input: arbitraryAbiCase({
+        maxArrayLength: 4,
+        maxBytesLength: 128,
+        maxDepth: 4,
+        maxTupleArity: 4,
+        minFixedArrayLength: 0,
+      }),
+    },
+    { numRuns },
+  )('encodeData matches ethers Interface', ({ input }) => {
+    expectFunction(input.parameters, input.values)
+  })
+
+  test('nested named dynamic values match ethers Interface', () => {
+    expectFunction(
+      [
+        {
+          components: [
+            { name: 'maker', type: 'address' },
+            {
+              components: [
+                { name: 'id', type: 'uint256' },
+                { name: 'memo', type: 'string' },
+                { name: 'payloads', type: 'bytes[]' },
+              ],
+              name: 'items',
+              type: 'tuple[2]',
+            },
+          ],
+          name: 'orders',
+          type: 'tuple[]',
+        },
+        { name: 'suffix', type: 'string[2]' },
+      ],
+      [
+        [
+          {
+            items: [
+              {
+                id: 2n ** 64n - 1n,
+                memo: '',
+                payloads: ['0x', `0x${'ab'.repeat(31)}`],
+              },
+              {
+                id: 2n ** 64n,
+                memo: '😀',
+                payloads: [`0x${'ab'.repeat(32)}`, `0x${'ab'.repeat(33)}`],
+              },
+            ],
+            maker: '0x0000000000000000000000000000000000000001',
+          },
+        ],
+        ['', 'a'.repeat(33)],
+      ],
+    )
+  })
+})
+
+function expectParameters(
+  parameters: readonly AbiParameters.Parameter[],
+  values: readonly unknown[],
+) {
+  const types = parameters.map((parameter) => ParamType.from(parameter))
+  const expected = coder.encode(types, values)
+  const encoded = AbiParameters.encode(parameters, values as never)
+  expect(encoded).toEqual(expected)
+}
+
+function expectFunction(
+  parameters: readonly AbiParameters.Parameter[],
+  values: readonly unknown[],
+) {
+  const abiFunction: AbiFunction.AbiFunction = {
+    inputs: parameters,
+    name: 'test',
+    outputs: [],
+    stateMutability: 'pure',
+    type: 'function',
+  }
+  const inputs = parameters
+    .map((parameter) => ParamType.from(parameter).format('full'))
+    .join(',')
+  const expected = new Interface([
+    `function ${abiFunction.name}(${inputs}) pure`,
+  ]).encodeFunctionData(abiFunction.name, values)
+  const encoded = AbiFunction.encodeData(abiFunction, values as never)
+  expect(encoded).toEqual(expected)
+}

package/src/core/_test/AbiParameters.encode.test.ts

@@ -1825,6 +1825,28 @@ test('invalid bytes', () => {
   )
 })
 
+test('invalid bytes type', () => {
+  expect(() =>
+    AbiParameters.encode([{ name: 'x', type: 'bytes0' }], ['0x']),
+  ).toThrowErrorMatchingInlineSnapshot(
+    '[AbiParameters.InvalidTypeError: Type `bytes0` is not a valid ABI Type.]',
+  )
+  expect(() =>
+    AbiParameters.encode(
+      [
+        { name: 'x', type: 'bytes33' },
+        { name: 'following', type: 'uint256' },
+      ],
+      [
+        '0x000000000000000000000000000000000000000000000000000000000000000000',
+        1n,
+      ],
+    ),
+  ).toThrowErrorMatchingInlineSnapshot(
+    '[AbiParameters.InvalidTypeError: Type `bytes33` is not a valid ABI Type.]',
+  )
+})
+
 test('integer out of range', () => {
   expect(() =>
     AbiParameters.encode(

package/src/core/_test/AbiParameters.fuzz.ts

@@ -32,5 +32,9 @@ function normalize(value: unknown): unknown {
   if (Array.isArray(value)) return value.map(normalize)
   if (typeof value === 'string' && /^0x[0-9a-fA-F]{40}$/.test(value))
     return value.toLowerCase()
+  if (value && typeof value === 'object')
+    return Object.fromEntries(
+      Object.entries(value).map(([key, value]) => [key, normalize(value)]),
+    )
   return value
 }

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

@@ -85,6 +85,80 @@ describe('encrypt', () => {
   })
 })
 
+describe('fromPrf', () => {
+  test('vector', async () => {
+    const key = await AesGcm.fromPrf(
+      '0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f',
+    )
+    const expectedKey = await globalThis.crypto.subtle.importKey(
+      'raw',
+      Bytes.fromHex(
+        '0x95c3c66b64baf063678e43d8aa98e1a4b4447c431fa9434b79e4a8c01ee85e07',
+      ),
+      { name: 'AES-GCM' },
+      false,
+      ['decrypt'],
+    )
+    const value = Bytes.fromString('i am a secret message')
+    const encrypted = await AesGcm.encrypt(value, key)
+
+    await expect(AesGcm.decrypt(encrypted, expectedKey)).resolves.toEqual(value)
+  })
+
+  test('value: Bytes', async () => {
+    const key = await AesGcm.fromPrf(
+      Bytes.fromHex(
+        '0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f',
+      ),
+    )
+    const value = Bytes.fromString('i am a secret message')
+
+    await expect(
+      AesGcm.decrypt(await AesGcm.encrypt(value, key), key),
+    ).resolves.toEqual(value)
+  })
+
+  test('behavior: CryptoKey properties', async () => {
+    const key = await AesGcm.fromPrf(new Uint8Array(32))
+
+    expect({
+      algorithm: key.algorithm,
+      extractable: key.extractable,
+      type: key.type,
+      usages: key.usages,
+    }).toMatchInlineSnapshot(`
+      {
+        "algorithm": {
+          "length": 256,
+          "name": "AES-GCM",
+        },
+        "extractable": false,
+        "type": "secret",
+        "usages": [
+          "encrypt",
+          "decrypt",
+        ],
+      }
+    `)
+  })
+
+  test('error: PRF output is too short', async () => {
+    await expect(
+      AesGcm.fromPrf(new Uint8Array(31)),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[AesGcm.InvalidPrfSizeError: PRF output must be exactly 32 bytes. Received 31 bytes.]`,
+    )
+  })
+
+  test('error: PRF output is too long', async () => {
+    await expect(
+      AesGcm.fromPrf(new Uint8Array(33)),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[AesGcm.InvalidPrfSizeError: PRF output must be exactly 32 bytes. Received 33 bytes.]`,
+    )
+  })
+})
+
 describe('getKey', () => {
   test('default', async () => {
     const key = await AesGcm.getKey({ password: 'qwerty' })
@@ -105,8 +179,10 @@ test('exports', () => {
       "ivLength",
       "decrypt",
       "encrypt",
+      "fromPrf",
       "getKey",
       "randomSalt",
+      "InvalidPrfSizeError",
     ]
   `)
 })

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

@@ -400,9 +400,16 @@ describe('fromRpc', () => {
         method: 'eth_getBlockByNumber',
         params: ['latest', true],
       })
-      .then(Block.fromRpc)
+      .then((block) => Block.fromRpc(block, { includeTransactions: true }))
 
-    expect(block).toMatchSnapshot()
+    const transactions = block?.transactions.map((transaction) => {
+      const { blockTimestamp: _, ...transaction_ } = {
+        blockTimestamp: undefined,
+        ...transaction,
+      }
+      return transaction_
+    })
+    expect({ ...block, transactions }).toMatchSnapshot()
   })
 })
 

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

@@ -1,5 +1,5 @@
 import { attest } from '@ark/attest'
-import { Ed25519 } from 'ox'
+import { type Bytes, Ed25519, type Hex } from 'ox'
 import { expectTypeOf, test } from 'vp/test'
 
 test('createKeyPair', () => {
@@ -28,6 +28,18 @@ test('createKeyPair', () => {
   }
 })
 
+test('fromPrf', () => {
+  const prf =
+    '0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f'
+
+  expectTypeOf(Ed25519.fromPrf(prf)).toEqualTypeOf<Hex.Hex>()
+  expectTypeOf(Ed25519.fromPrf(new Uint8Array(32))).toEqualTypeOf<Hex.Hex>()
+  expectTypeOf(Ed25519.fromPrf(prf, { as: 'Hex' })).toEqualTypeOf<Hex.Hex>()
+  expectTypeOf(
+    Ed25519.fromPrf(prf, { as: 'Bytes' }),
+  ).toEqualTypeOf<Bytes.Bytes>()
+})
+
 test('getPublicKey', () => {
   // Default behavior (Hex)
   {