viem 0.3.24 → 0.3.27

package/src/utils/abi/decodeAbiParameters.ts

@@ -6,7 +6,6 @@ import type {
 } from 'abitype'
 
 import {
-  AbiDecodingDataSizeInvalidError,
   AbiDecodingDataSizeTooSmallError,
   AbiDecodingZeroDataError,
   InvalidAbiDecodingTypeError,
@@ -38,8 +37,12 @@ export function decodeAbiParameters<
 >(params: Narrow<TParams>, data: Hex): DecodeAbiParametersReturnType<TParams> {
   if (data === '0x' && (params as unknown[]).length > 0)
     throw new AbiDecodingZeroDataError()
-  if (size(data) % 32 !== 0)
-    throw new AbiDecodingDataSizeInvalidError({ data, size: size(data) })
+  if (size(data) && size(data) < 32)
+    throw new AbiDecodingDataSizeTooSmallError({
+      data,
+      params: params as readonly AbiParameter[],
+      size: size(data),
+    })
   return decodeParams({
     data,
     params: params as readonly AbiParameter[],
@@ -102,7 +105,7 @@ function decodeParam({
     return decodeBytes(data, { param, position })
   }
 
-  const value = slice(data, position, position + 32) as Hex
+  const value = slice(data, position, position + 32, { strict: true }) as Hex
   if (param.type.startsWith('uint') || param.type.startsWith('int')) {
     return decodeNumber(value, { param })
   }
@@ -139,9 +142,13 @@ function decodeArray<TParam extends AbiParameter>(
   // we will need to decode the offset of the array data.
   if (!length) {
     // Get the offset of the array data.
-    const offset = hexToNumber(slice(data, position, position + 32))
+    const offset = hexToNumber(
+      slice(data, position, position + 32, { strict: true }),
+    )
     // Get the length of the array from the offset.
-    const length = hexToNumber(slice(data, offset, offset + 32))
+    const length = hexToNumber(
+      slice(data, offset, offset + 32, { strict: true }),
+    )
 
     let consumed = 0
     const value: AbiParameterToPrimitiveType<TParam>[] = []
@@ -169,7 +176,9 @@ function decodeArray<TParam extends AbiParameter>(
     let consumed = 0
     const value: AbiParameterToPrimitiveType<TParam>[] = []
     for (let i = 0; i < length; ++i) {
-      const offset = hexToNumber(slice(data, position, position + 32))
+      const offset = hexToNumber(
+        slice(data, position, position + 32, { strict: true }),
+      )
       const decodedChild = decodeParam({
         data: slice(data, offset),
         param,
@@ -210,15 +219,23 @@ function decodeBytes<TParam extends AbiParameter>(
   if (!size) {
     // If we don't have a size, we're dealing with a dynamic-size array
     // so we need to read the offset of the data part first.
-    const offset = hexToNumber(slice(data, position, position + 32))
-    const length = hexToNumber(slice(data, offset, offset + 32))
+    const offset = hexToNumber(
+      slice(data, position, position + 32, { strict: true }),
+    )
+    const length = hexToNumber(
+      slice(data, offset, offset + 32, { strict: true }),
+    )
     // If there is no length, we have zero data.
     if (length === 0) return { consumed: 32, value: '0x' }
-    const value = slice(data, offset + 32, offset + 32 + length)
+    const value = slice(data, offset + 32, offset + 32 + length, {
+      strict: true,
+    })
     return { consumed: 32, value }
   }
 
-  const value = slice(data, position, position + parseInt(size))
+  const value = slice(data, position, position + parseInt(size), {
+    strict: true,
+  })
   return { consumed: 32, value }
 }
 
@@ -238,12 +255,14 @@ function decodeNumber<TParam extends AbiParameter>(
 }
 
 function decodeString(data: Hex, { position }: { position: number }) {
-  const offset = hexToNumber(slice(data, position, position + 32))
-  const length = hexToNumber(slice(data, offset, offset + 32))
+  const offset = hexToNumber(
+    slice(data, position, position + 32, { strict: true }),
+  )
+  const length = hexToNumber(slice(data, offset, offset + 32, { strict: true }))
   // If there is no length, we have zero data (empty string).
   if (length === 0) return { consumed: 32, value: '' }
   const value = hexToString(
-    trim(slice(data, offset + 32, offset + 32 + length)),
+    trim(slice(data, offset + 32, offset + 32 + length, { strict: true })),
   )
   return { consumed: 32, value }
 }
@@ -266,7 +285,9 @@ function decodeTuple<
   // If the tuple has a dynamic child, we must first decode the offset to the
   // tuple data.
   if (hasDynamicChild(param)) {
-    const offset = hexToNumber(slice(data, position, position + 32))
+    const offset = hexToNumber(
+      slice(data, position, position + 32, { strict: true }),
+    )
     // Decode each component of the tuple, starting at the offset.
     for (let i = 0; i < param.components.length; ++i) {
       const component = param.components[i]

package/src/utils/abi/decodeEventLog.ts

@@ -93,8 +93,8 @@ export function decodeEventLog<
   let args: any = isUnnamed ? [] : {}
 
   // Decode topics (indexed args).
+  const indexedInputs = inputs.filter((x) => 'indexed' in x && x.indexed)
   if (argTopics.length > 0) {
-    const indexedInputs = inputs.filter((x) => 'indexed' in x && x.indexed)
     for (let i = 0; i < indexedInputs.length; i++) {
       const param = indexedInputs[i]
       const topic = argTopics[i]
@@ -108,15 +108,15 @@ export function decodeEventLog<
   }
 
   // Decode data (non-indexed args).
+  const nonIndexedInputs = inputs.filter((x) => !('indexed' in x && x.indexed))
   if (data && data !== '0x') {
-    const params = inputs.filter((x) => !('indexed' in x && x.indexed))
     try {
-      const decodedData = decodeAbiParameters(params, data)
+      const decodedData = decodeAbiParameters(nonIndexedInputs, data)
       if (decodedData) {
         if (isUnnamed) args = [...args, ...decodedData]
         else {
-          for (let i = 0; i < params.length; i++) {
-            args[params[i].name!] = decodedData[i]
+          for (let i = 0; i < nonIndexedInputs.length; i++) {
+            args[nonIndexedInputs[i].name!] = decodedData[i]
           }
         }
       }

package/src/utils/data/isHex.ts

@@ -1,7 +1,10 @@
 import type { Hex } from '../../types/misc.js'
 
-export function isHex(value: unknown): value is Hex {
+export function isHex(
+  value: unknown,
+  { strict = true }: { strict?: boolean } = {},
+): value is Hex {
   if (!value) return false
   if (typeof value !== 'string') return false
-  return /^0x[0-9a-fA-F]*$/.test(value)
+  return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith('0x')
 }

package/src/utils/data/size.ts

@@ -9,6 +9,6 @@ import { isHex } from './isHex.js'
  * @returns The size of the value (in bytes).
  */
 export function size(value: Hex | ByteArray) {
-  if (isHex(value)) return Math.ceil((value.length - 2) / 2)
+  if (isHex(value, { strict: false })) return Math.ceil((value.length - 2) / 2)
   return value.length
 }

package/src/utils/data/slice.ts

@@ -19,15 +19,38 @@ export function slice<TValue extends ByteArray | Hex>(
   value: TValue,
   start?: number,
   end?: number,
+  { strict }: { strict?: boolean } = {},
 ): SliceReturnType<TValue> {
-  if (isHex(value))
-    return sliceHex(value as Hex, start, end) as SliceReturnType<TValue>
-  return sliceBytes(value as ByteArray, start, end) as SliceReturnType<TValue>
+  if (isHex(value, { strict: false }))
+    return sliceHex(value as Hex, start, end, {
+      strict,
+    }) as SliceReturnType<TValue>
+  return sliceBytes(value as ByteArray, start, end, {
+    strict,
+  }) as SliceReturnType<TValue>
 }
 
 function assertStartOffset(value: Hex | ByteArray, start?: number) {
   if (typeof start === 'number' && start > 0 && start > size(value) - 1)
-    throw new SliceOffsetOutOfBoundsError({ offset: start, size: size(value) })
+    throw new SliceOffsetOutOfBoundsError({
+      offset: start,
+      position: 'start',
+      size: size(value),
+    })
+}
+
+function assertEndOffset(value: Hex | ByteArray, start?: number, end?: number) {
+  if (
+    typeof start === 'number' &&
+    typeof end === 'number' &&
+    size(value) !== end - start
+  ) {
+    throw new SliceOffsetOutOfBoundsError({
+      offset: end,
+      position: 'end',
+      size: size(value),
+    })
+  }
 }
 
 /**
@@ -38,12 +61,15 @@ function assertStartOffset(value: Hex | ByteArray, start?: number) {
  * @param end The end offset (in bytes).
  */
 export function sliceBytes(
-  value: ByteArray,
+  value_: ByteArray,
   start?: number,
   end?: number,
+  { strict }: { strict?: boolean } = {},
 ): ByteArray {
-  assertStartOffset(value, start)
-  return value.slice(start, end)
+  assertStartOffset(value_, start)
+  const value = value_.slice(start, end)
+  if (strict) assertEndOffset(value, start, end)
+  return value
 }
 
 /**
@@ -53,10 +79,16 @@ export function sliceBytes(
  * @param start The start offset (in bytes).
  * @param end The end offset (in bytes).
  */
-export function sliceHex(value_: Hex, start?: number, end?: number): Hex {
+export function sliceHex(
+  value_: Hex,
+  start?: number,
+  end?: number,
+  { strict }: { strict?: boolean } = {},
+): Hex {
   assertStartOffset(value_, start)
-  const value = value_
+  const value = `0x${value_
     .replace('0x', '')
-    .slice((start ?? 0) * 2, (end ?? value_.length) * 2)
-  return `0x${value}`
+    .slice((start ?? 0) * 2, (end ?? value_.length) * 2)}` as const
+  if (strict) assertEndOffset(value, start, end)
+  return value
 }

package/src/utils/hash/keccak256.ts

@@ -16,7 +16,9 @@ export function keccak256<TTo extends To = 'hex'>(
   to_?: TTo,
 ): Keccak256Hash<TTo> {
   const to = to_ || 'hex'
-  const bytes = keccak_256(isHex(value) ? toBytes(value) : value)
+  const bytes = keccak_256(
+    isHex(value, { strict: false }) ? toBytes(value) : value,
+  )
   if (to === 'bytes') return bytes as Keccak256Hash<TTo>
   return toHex(bytes) as Keccak256Hash<TTo>
 }

package/src/utils/promise/createBatchScheduler.ts

@@ -10,6 +10,25 @@ type PendingPromise<TReturnType extends readonly unknown[] = any> = {
 
 type SchedulerItem = { args: unknown; pendingPromise: PendingPromise }
 
+export type CreateBatchSchedulerArguments<
+  TParameters = unknown,
+  TReturnType extends readonly unknown[] = readonly unknown[],
+> = {
+  fn: (args: TParameters[]) => Promise<TReturnType>
+  id: number | string
+  shouldSplitBatch?: (args: TParameters[]) => boolean
+  wait?: number
+}
+export type CreateBatchSchedulerReturnType<
+  TParameters = unknown,
+  TReturnType extends readonly unknown[] = readonly unknown[],
+> = {
+  flush: () => void
+  schedule: TParameters extends undefined
+    ? (args?: TParameters) => Promise<Resolved<TReturnType>>
+    : (args: TParameters) => Promise<Resolved<TReturnType>>
+}
+
 const schedulerCache = new Map<number | string, SchedulerItem[]>()
 
 export function createBatchScheduler<
@@ -20,12 +39,10 @@ export function createBatchScheduler<
   id,
   shouldSplitBatch,
   wait = 0,
-}: {
-  fn: (args: TParameters[]) => Promise<TReturnType>
-  id: number | string
-  shouldSplitBatch?: (args: TParameters[]) => boolean
-  wait?: number
-}) {
+}: CreateBatchSchedulerArguments<
+  TParameters,
+  TReturnType
+>): CreateBatchSchedulerReturnType<TParameters, TReturnType> {
   const exec = async () => {
     const scheduler = getScheduler()
     flush()
@@ -78,5 +95,5 @@ export function createBatchScheduler<
       setTimeout(exec, wait)
       return promise
     },
-  }
+  } as unknown as CreateBatchSchedulerReturnType<TParameters, TReturnType>
 }

package/src/utils/rpc.ts

@@ -7,6 +7,7 @@ import {
   WebSocketRequestError,
 } from '../errors/request.js'
 
+import { createBatchScheduler } from './promise/createBatchScheduler.js'
 import { withTimeout } from './promise/withTimeout.js'
 import { stringify } from './stringify.js'
 
@@ -146,61 +147,70 @@ export async function getSocket(url_: string) {
   // If the socket already exists, return it.
   if (socket) return socket
 
-  let WebSocket = await import('isomorphic-ws')
-  // Workaround for Vite.
-  // https://github.com/vitejs/vite/issues/9703
-  // TODO: Remove when issue is resolved.
-  if (
-    (WebSocket as unknown as { default?: typeof WebSocket }).default
-      ?.constructor
-  )
-    WebSocket = (WebSocket as unknown as { default: typeof WebSocket }).default
-  else WebSocket = WebSocket.WebSocket
-
-  const webSocket = new WebSocket(url)
-
-  // Set up a cache for incoming "synchronous" requests.
-  const requests = new Map<Id, CallbackFn>()
+  const { schedule } = createBatchScheduler<undefined, [Socket]>({
+    id: urlKey,
+    fn: async () => {
+      let WebSocket = await import('isomorphic-ws')
+      // Workaround for Vite.
+      // https://github.com/vitejs/vite/issues/9703
+      // TODO: Remove when issue is resolved.
+      if (
+        (WebSocket as unknown as { default?: typeof WebSocket }).default
+          ?.constructor
+      )
+        WebSocket = (WebSocket as unknown as { default: typeof WebSocket })
+          .default
+      else WebSocket = WebSocket.WebSocket
+
+      const webSocket = new WebSocket(url)
+
+      // Set up a cache for incoming "synchronous" requests.
+      const requests = new Map<Id, CallbackFn>()
+
+      // Set up a cache for subscriptions (eth_subscribe).
+      const subscriptions = new Map<Id, CallbackFn>()
+
+      const onMessage: (event: MessageEvent) => void = ({ data }) => {
+        const message: RpcResponse = JSON.parse(data as string)
+        const isSubscription = message.method === 'eth_subscription'
+        const id = isSubscription ? message.params.subscription : message.id
+        const cache = isSubscription ? subscriptions : requests
+        const callback = cache.get(id)
+        if (callback) callback({ data })
+        if (!isSubscription) cache.delete(id)
+      }
+      const onClose = () => {
+        sockets.delete(urlKey)
+        webSocket.removeEventListener('close', onClose)
+        webSocket.removeEventListener('message', onMessage)
+      }
 
-  // Set up a cache for subscriptions (eth_subscribe).
-  const subscriptions = new Map<Id, CallbackFn>()
+      // Setup event listeners for RPC & subscription responses.
+      webSocket.addEventListener('close', onClose)
+      webSocket.addEventListener('message', onMessage)
 
-  const onMessage: (event: MessageEvent) => void = ({ data }) => {
-    const message: RpcResponse = JSON.parse(data as string)
-    const isSubscription = message.method === 'eth_subscription'
-    const id = isSubscription ? message.params.subscription : message.id
-    const cache = isSubscription ? subscriptions : requests
-    const callback = cache.get(id)
-    if (callback) callback({ data })
-    if (!isSubscription) cache.delete(id)
-  }
-  const onClose = () => {
-    sockets.delete(urlKey)
-    webSocket.removeEventListener('close', onClose)
-    webSocket.removeEventListener('message', onMessage)
-  }
-
-  // Setup event listeners for RPC & subscription responses.
-  webSocket.addEventListener('close', onClose)
-  webSocket.addEventListener('message', onMessage)
+      // Wait for the socket to open.
+      if (webSocket.readyState === WebSocket.CONNECTING) {
+        await new Promise((resolve, reject) => {
+          if (!webSocket) return
+          webSocket.onopen = resolve
+          webSocket.onerror = reject
+        })
+      }
 
-  // Wait for the socket to open.
-  if (webSocket.readyState === WebSocket.CONNECTING) {
-    await new Promise((resolve, reject) => {
-      if (!webSocket) return
-      webSocket.onopen = resolve
-      webSocket.onerror = reject
-    })
-  }
+      // Create a new socket instance.
+      socket = Object.assign(webSocket, {
+        requests,
+        subscriptions,
+      })
+      sockets.set(urlKey, socket)
 
-  // Create a new socket instance.
-  socket = Object.assign(webSocket, {
-    requests,
-    subscriptions,
+      return [socket]
+    },
   })
-  sockets.set(urlKey, socket)
 
-  return socket
+  const [_, [socket_]] = await schedule()
+  return socket_
 }
 
 function webSocket(