ox 0.14.57 → 0.14.58

package/core/Hex.ts

@@ -34,17 +34,24 @@ export function assert(
   value: unknown,
   options: assert.Options = {},
 ): asserts value is Hex {
-  const { strict = false } = options
+  const { even = false, strict = false } = options
   if (!value) throw new InvalidHexTypeError(value)
   if (typeof value !== 'string') throw new InvalidHexTypeError(value)
   if (strict) {
     if (!/^0x[0-9a-fA-F]*$/.test(value)) throw new InvalidHexValueError(value)
   }
   if (!value.startsWith('0x')) throw new InvalidHexValueError(value)
+  if (even && value.length % 2 !== 0) throw new InvalidLengthError(value as Hex)
 }
 
 export declare namespace assert {
   type Options = {
+    /**
+     * Checks if the {@link ox#Hex.Hex} value has an even number of hexadecimal characters (whole bytes).
+     * Keep disabled for RPC quantities (e.g. `0x0`, `0x400`).
+     * @default false
+     */
+    even?: boolean | undefined
     /** Checks if the {@link ox#Hex.Hex} value contains invalid hexadecimal characters. @default false */
     strict?: boolean | undefined
   }
@@ -52,6 +59,7 @@ export declare namespace assert {
   type ErrorType =
     | InvalidHexTypeError
     | InvalidHexValueError
+    | InvalidLengthError
     | Errors.GlobalErrorType
 }
 
@@ -741,9 +749,9 @@ export function validate(
   value: unknown,
   options: validate.Options = {},
 ): value is Hex {
-  const { strict = false } = options
+  const { even = false, strict = false } = options
   try {
-    assert(value, { strict })
+    assert(value, { even, strict })
     return true
   } catch {
     return false
@@ -752,6 +760,12 @@ export function validate(
 
 export declare namespace validate {
   type Options = {
+    /**
+     * Checks if the {@link ox#Hex.Hex} value has an even number of hexadecimal characters (whole bytes).
+     * Keep disabled for RPC quantities (e.g. `0x0`, `0x400`).
+     * @default false
+     */
+    even?: boolean | undefined
     /** Checks if the {@link ox#Hex.Hex} value contains invalid hexadecimal characters. @default false */
     strict?: boolean | undefined
   }

package/core/RpcTransport.ts

@@ -95,8 +95,14 @@ export function fromHttp<
             ? await fetchOptions_(body_)
             : fetchOptions_
 
-        const response = await promise.withTimeout(
-          ({ signal }) => {
+        const { data, response } = await promise.withTimeout(
+          async ({ signal }) => {
+            // Abort on whichever signal fires first, so that a caller's
+            // `signal` does not disable the timeout.
+            const signals = [
+              fetchOptions?.signal,
+              timeout > 0 ? signal : null,
+            ].filter((s): s is AbortSignal => Boolean(s))
             const init: RequestInit = {
               ...fetchOptions,
               body,
@@ -105,10 +111,40 @@ export function fromHttp<
                 ...fetchOptions?.headers,
               },
               method: fetchOptions?.method ?? 'POST',
-              signal: fetchOptions?.signal ?? (timeout > 0 ? signal : null),
+              signal: (() => {
+                if (signals.length < 2) return signals[0] ?? null
+                // Runtimes without `AbortSignal.any` (e.g. Node < 18.17) keep
+                // only the caller's signal, as before.
+                if (typeof AbortSignal.any !== 'function') return signals[0]!
+                return AbortSignal.any(signals)
+              })(),
             }
             const request = new Request(url, init)
-            return fetchFn(request)
+            const response = await fetchFn(request)
+
+            // Read the body within the timeout too, so a response that stalls
+            // after its headers cannot hang the request.
+            const data = await (async () => {
+              if (
+                response.headers
+                  .get('Content-Type')
+                  ?.startsWith('application/json')
+              )
+                return response.json()
+              return response.text().then((data) => {
+                try {
+                  return JSON.parse(data || '{}')
+                } catch (_err) {
+                  if (response.ok)
+                    throw new MalformedResponseError({
+                      response: data,
+                    })
+                  return { error: data }
+                }
+              })
+            })()
+
+            return { data, response }
           },
           {
             timeout,
@@ -116,24 +152,6 @@ export function fromHttp<
           },
         )
 
-        const data = await (async () => {
-          if (
-            response.headers.get('Content-Type')?.startsWith('application/json')
-          )
-            return response.json()
-          return response.text().then((data) => {
-            try {
-              return JSON.parse(data || '{}')
-            } catch (_err) {
-              if (response.ok)
-                throw new MalformedResponseError({
-                  response: data,
-                })
-              return { error: data }
-            }
-          })
-        })()
-
         if (!response.ok)
           throw new HttpError({
             body,

package/core/TypedData.ts

@@ -393,7 +393,7 @@ export function extractEip712DomainTypes(
 ): Parameter[] {
   return [
     typeof domain?.name === 'string' && { name: 'name', type: 'string' },
-    domain?.version && { name: 'version', type: 'string' },
+    typeof domain?.version === 'string' && { name: 'version', type: 'string' },
     (typeof domain?.chainId === 'number' ||
       typeof domain?.chainId === 'bigint') && {
       name: 'chainId',

package/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,
@@ -466,8 +467,9 @@ export function normalizeSignature(signature: string): string {
 
     // Ignore spaces
     if (char === ' ') {
-      // If the previous character is a separator, and the current section isn't empty, we want to deactivate.
-      if (signature[i - 1] !== ',' && current !== ',' && current !== ',(') {
+      // A space directly after a `(` or `,` separator is leading whitespace.
+      // Otherwise, it ends the type, so we want to deactivate.
+      if (!current.endsWith(',') && !current.endsWith('(')) {
         current = ''
         active = false
       }
@@ -508,9 +510,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,
+              )
             )
           },
         )
@@ -530,15 +535,16 @@ export function isArgOfType(
         return argType === 'string' || arg instanceof Uint8Array
 
       // fixed-length (`<type>[M]`) and dynamic (`<type>[]`) arrays
-      // https://regexr.com/6va6i
-      if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
+      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(/(\[[0-9]{0,}\])$/, ''),
+              type,
             } as AbiParameters.Parameter),
           )
         )
@@ -557,32 +563,65 @@ export function getAmbiguousTypes(
 ): AbiParameters.Parameter['type'][] | undefined {
   for (const parameterIndex in sourceParameters) {
     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 types = [sourceParameter.type, targetParameter.type]
 
+    const value = args[parameterIndex]
+
     const ambiguous = (() => {
       if (types.includes('address') && types.includes('bytes20')) return true
-      if (types.includes('address') && types.includes('string'))
-        return Address.validate(args[parameterIndex] as Address.Address, {
-          strict: false,
-        })
-      if (types.includes('address') && types.includes('bytes'))
-        return Address.validate(args[parameterIndex] as Address.Address, {
-          strict: false,
-        })
+      // An `undefined` value comes from an empty array, which matches both types.
+      if (
+        types.includes('address') &&
+        (types.includes('string') || types.includes('bytes'))
+      )
+        return (
+          value === undefined ||
+          Address.validate(value as Address.Address, { strict: false })
+        )
       return false
     })()
 
@@ -591,3 +630,13 @@ export function getAmbiguousTypes(
 
   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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ox",
   "description": "Ethereum Standard Library",
-  "version": "0.14.57",
+  "version": "0.14.58",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",

package/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '0.14.57'
+export const version = '0.14.58'