ox 1.8.9 → 1.8.10

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

@@ -242,6 +242,54 @@ describe('fromHttp', () => {
 
     await server.close()
   })
+
+  test('behavior: caller signal without `AbortSignal.any`', async () => {
+    const server = await createHttpServer((_, res) => {
+      res.end(JSON.stringify({ id: 0, jsonrpc: '2.0', result: 'wagmi' }))
+    })
+
+    const transport = RpcTransport.fromHttp(server.url, {
+      timeout: 50,
+      fetchOptions: {
+        signal: new AbortController().signal,
+      },
+    })
+
+    const descriptor = Object.getOwnPropertyDescriptor(AbortSignal, 'any')!
+    Object.defineProperty(AbortSignal, 'any', {
+      configurable: true,
+      value: undefined,
+    })
+    try {
+      await expect(
+        transport.request({ method: 'eth_accounts' }),
+      ).resolves.toMatchInlineSnapshot(`"wagmi"`)
+    } finally {
+      Object.defineProperty(AbortSignal, 'any', descriptor)
+      await server.close()
+    }
+  })
+
+  test('behavior: timeout covers a response body that stalls after its headers', async () => {
+    const server = await createHttpServer(async (_, res) => {
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.write('{"id":0,"jsonrpc":"2.0",')
+      await setTimeout(200)
+      res.end('"result":"wagmi"}')
+    })
+
+    const transport = RpcTransport.fromHttp(server.url, {
+      timeout: 50,
+    })
+
+    await expect(() =>
+      transport.request({ method: 'eth_accounts' }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Promise.TimeoutError: Operation timed out.]`,
+    )
+
+    await server.close()
+  })
 })
 
 test('exports', () => {

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

@@ -1,4 +1,11 @@
-import { Bytes, Hex, Signature, Solidity, TxEnvelopeEip1559 } from 'ox'
+import {
+  Bytes,
+  Hex,
+  Secp256k1,
+  Signature,
+  Solidity,
+  TxEnvelopeEip1559,
+} from 'ox'
 import { describe, expect, test } from 'vp/test'
 
 describe('assert', () => {
@@ -488,6 +495,40 @@ describe('serialize', () => {
       `"0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8"`,
     )
   })
+
+  test('behavior: `r` and `s` shorter than 32 bytes', () => {
+    const signature = Signature.toHex({
+      r: '0x1cdb3cbf94c7059e0e16d2ba046daef144d77384995a66f379194b638fc07e',
+      s: '0xc3d1ccd2c334876b9f8ef0ba3725c30dd5e1def225df36efa406d881ed610b',
+      yParity: 1,
+    })
+    expect(signature).toMatchInlineSnapshot(
+      `"0x001cdb3cbf94c7059e0e16d2ba046daef144d77384995a66f379194b638fc07e00c3d1ccd2c334876b9f8ef0ba3725c30dd5e1def225df36efa406d881ed610b1c"`,
+    )
+    expect(Hex.size(signature)).toMatchInlineSnapshot(`65`)
+  })
+
+  test('behavior: short `s` round-trips through recovery', () => {
+    const payload =
+      '0x44caf484852acee09d52b2802dba26d3c8ab3d28c7abcc1398b87898115633ec'
+    const signature = Signature.fromHex(
+      Signature.toHex({
+        r: '0xdf1cdb3cbf94c7059e0e16d2ba046daef144d77384995a66f379194b638fc07e',
+        s: '0xc3d1ccd2c334876b9f8ef0ba3725c30dd5e1def225df36efa406d881ed610b',
+        yParity: 1,
+      }),
+    )
+    expect(signature).toMatchInlineSnapshot(`
+      {
+        "r": "0xdf1cdb3cbf94c7059e0e16d2ba046daef144d77384995a66f379194b638fc07e",
+        "s": "0x00c3d1ccd2c334876b9f8ef0ba3725c30dd5e1def225df36efa406d881ed610b",
+        "yParity": 1,
+      }
+    `)
+    expect(
+      Secp256k1.recoverAddress({ payload, signature }),
+    ).toMatchInlineSnapshot(`"0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266"`)
+  })
 })
 
 describe('toBytes', () => {

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

@@ -791,6 +791,23 @@ describe('extractEip712DomainTypes', () => {
   test('empty', () => {
     expect(TypedData.extractEip712DomainTypes({})).toMatchInlineSnapshot('[]')
   })
+
+  test('empty version', () => {
+    expect(
+      TypedData.extractEip712DomainTypes({ name: 'Ether Mail', version: '' }),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "name": "name",
+          "type": "string",
+        },
+        {
+          "name": "version",
+          "type": "string",
+        },
+      ]
+    `)
+  })
 })
 
 describe('getSignPayload', () => {
@@ -849,6 +866,18 @@ describe('getSignPayload', () => {
     )
   })
 
+  test('domain: empty version', () => {
+    expect(
+      TypedData.getSignPayload({
+        ...typedData.complex,
+        domain: { name: 'Ether Mail', version: '' },
+        primaryType: 'Mail',
+      }),
+    ).toMatchInlineSnapshot(
+      `"0xa437e12ee2fd4391429d9714be617951b7e69fb61dc520ad6fb8230d03b7508c"`,
+    )
+  })
+
   test('domain: bigint chainId produces same hash as number chainId', () => {
     const typedDataWithNumberChainId = {
       domain: {

package/src/core/internal/abiItem.ts

@@ -4,6 +4,7 @@ import type * as AbiItem from '../AbiItem.js'
 import type * as AbiParameters from '../AbiParameters.js'
 import * as Address from '../Address.js'
 import * as Errors from '../Errors.js'
+import { getArrayComponents } from './abiParameters.js'
 import type {
   Compute,
   IsNever,
@@ -570,20 +571,6 @@ const integerTypeRegex =
  */
 const fixedBytesTypeRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/
 
-/**
- * Fixed-length (`<type>[M]`) / dynamic (`<type>[]`) array regex.
- *
- * @internal
- */
-const arrayTypeRegex = /[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/
-
-/**
- * Strips a single trailing `[...]` array suffix from a type.
- *
- * @internal
- */
-const arraySuffixStripRegex = /(\[[0-9]{0,}\])$/
-
 /** @internal */
 export function isArgOfType(
   arg: unknown,
@@ -604,9 +591,12 @@ export function isArgOfType(
       if (abiParameterType === 'tuple' && 'components' in abiParameter)
         return Object.values(abiParameter.components).every(
           (component, index) => {
-            return isArgOfType(
-              Object.values(arg as unknown[] | Record<string, unknown>)[index],
-              component as AbiParameters.Parameter,
+            return (
+              argType === 'object' &&
+              isArgOfType(
+                getComponentValue(arg, component, index),
+                component as AbiParameters.Parameter,
+              )
             )
           },
         )
@@ -617,14 +607,17 @@ export function isArgOfType(
       if (fixedBytesTypeRegex.test(abiParameterType))
         return argType === 'string' || arg instanceof Uint8Array
 
-      if (arrayTypeRegex.test(abiParameterType)) {
+      // Fixed-length (`<type>[M]`) and dynamic (`<type>[]`) arrays.
+      const arrayComponents = getArrayComponents(abiParameterType)
+      if (arrayComponents) {
+        const [length, type] = arrayComponents
         return (
           Array.isArray(arg) &&
+          (length === null || arg.length === length) &&
           arg.every((x: unknown) =>
             isArgOfType(x, {
               ...abiParameter,
-              // Pop off `[]` or `[M]` from end of type
-              type: abiParameterType.replace(arraySuffixStripRegex, ''),
+              type,
             } as AbiParameters.Parameter),
           )
         )
@@ -649,19 +642,49 @@ export function getAmbiguousTypes(
     parameterIndex++
   ) {
     const sourceParameter = sourceParameters[parameterIndex]!
-    const targetParameter = targetParameters[parameterIndex]!
+    const targetParameter = targetParameters[parameterIndex]
+    if (!targetParameter) continue
 
     if (
       sourceParameter.type === 'tuple' &&
       targetParameter.type === 'tuple' &&
       'components' in sourceParameter &&
       'components' in targetParameter
-    )
-      return getAmbiguousTypes(
+    ) {
+      const value = args[parameterIndex]
+      const types = getAmbiguousTypes(
         sourceParameter.components,
         targetParameter.components,
-        (args as any)[parameterIndex],
+        sourceParameter.components.map((component, index) =>
+          getComponentValue(value, component, index),
+        ),
+      )
+      if (types) return types
+      continue
+    }
+
+    const sourceArray = getArrayComponents(sourceParameter.type)
+    const targetArray = getArrayComponents(targetParameter.type)
+    if (sourceArray && targetArray) {
+      // Every item matches both element types, so the first item (or `undefined` for an empty array) decides.
+      const types = getAmbiguousTypes(
+        [
+          {
+            ...sourceParameter,
+            type: sourceArray[1],
+          } as AbiParameters.Parameter,
+        ],
+        [
+          {
+            ...targetParameter,
+            type: targetArray[1],
+          } as AbiParameters.Parameter,
+        ],
+        [(args[parameterIndex] as readonly unknown[] | undefined)?.[0]],
       )
+      if (types) return types
+      continue
+    }
 
     const sourceType = sourceParameter.type
     const targetType = targetParameter.type
@@ -679,10 +702,21 @@ export function getAmbiguousTypes(
       (sourceType === 'address' && targetType === 'bytes') ||
       (sourceType === 'bytes' && targetType === 'address')
     )
-      ambiguous = Address.validate(arg, { strict: false })
+      // An `undefined` value comes from an empty array, which matches both types.
+      ambiguous = arg === undefined || Address.validate(arg, { strict: false })
 
     if (ambiguous) return [sourceType, targetType]
   }
 
   return
 }
+
+// Reads a tuple component's value by index from arrays and by name from objects, like `AbiParameters.encode`.
+function getComponentValue(
+  arg: unknown,
+  component: AbiParameters.Parameter,
+  index: number,
+): unknown {
+  if (Array.isArray(arg)) return arg[index]
+  return (arg as Record<string, unknown> | undefined)?.[component.name!]
+}

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.8.9'
+export const version = '1.8.10'