viem 2.35.0 → 2.36.0-jxom-erc8010-20250826223301

package/utils/abi/encodeErrorResult.ts

@@ -4,19 +4,18 @@ import {
   AbiErrorInputsNotFoundError,
   AbiErrorNotFoundError,
 } from '../../errors/abi.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type {
   ContractErrorArgs,
   ContractErrorName,
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
 import {
   type ToFunctionSelectorErrorType,
   toFunctionSelector,
 } from '../hash/toFunctionSelector.js'
-
-import type { ErrorType } from '../../errors/utils.js'
-import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import {
   type EncodeAbiParametersErrorType,
   encodeAbiParameters,

package/utils/abi/encodeEventTopics.ts

@@ -134,7 +134,10 @@ export type EncodeArgErrorType =
 function encodeArg({
   param,
   value,
-}: { param: AbiParameter; value: AbiParameterToPrimitiveType<AbiParameter> }) {
+}: {
+  param: AbiParameter
+  value: AbiParameterToPrimitiveType<AbiParameter>
+}) {
   if (param.type === 'string' || param.type === 'bytes')
     return keccak256(toBytes(value as string))
   if (param.type === 'tuple' || param.type.match(/^(.*)\[(\d+)?\]$/))

package/utils/abi/encodeFunctionData.ts

@@ -1,16 +1,15 @@
 import type { Abi, AbiStateMutability, ExtractAbiFunctions } from 'abitype'
 
 import type { AbiFunctionNotFoundErrorType } from '../../errors/abi.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type {
   ContractFunctionArgs,
   ContractFunctionName,
 } from '../../types/contract.js'
-import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
-import type { ToFunctionSelectorErrorType } from '../hash/toFunctionSelector.js'
-
-import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
 import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
+import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
+import type { ToFunctionSelectorErrorType } from '../hash/toFunctionSelector.js'
 import {
   type EncodeAbiParametersErrorType,
   encodeAbiParameters,

package/utils/abi/encodeFunctionResult.ts

@@ -5,12 +5,11 @@ import {
   AbiFunctionOutputsNotFoundError,
   InvalidArrayError,
 } from '../../errors/abi.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type {
   ContractFunctionName,
   ContractFunctionReturnType,
 } from '../../types/contract.js'
-
-import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
 import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import {

package/utils/abi/encodePacked.ts

@@ -28,10 +28,10 @@ import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
 import { type PadErrorType, pad } from '../data/pad.js'
 import {
   type BoolToHexErrorType,
-  type NumberToHexErrorType,
-  type StringToHexErrorType,
   boolToHex,
+  type NumberToHexErrorType,
   numberToHex,
+  type StringToHexErrorType,
   stringToHex,
 } from '../encoding/toHex.js'
 import { arrayRegex, bytesRegex, integerRegex } from '../regex.js'
@@ -107,7 +107,7 @@ function encode<const packedAbiType extends PackedAbiType | unknown>(
   const intMatch = (type as string).match(integerRegex)
   if (intMatch) {
     const [_type, baseType, bits = '256'] = intMatch
-    const size = Number.parseInt(bits) / 8
+    const size = Number.parseInt(bits, 10) / 8
     return numberToHex(value as number, {
       size: isArray ? 32 : size,
       signed: baseType === 'int',
@@ -117,9 +117,9 @@ function encode<const packedAbiType extends PackedAbiType | unknown>(
   const bytesMatch = (type as string).match(bytesRegex)
   if (bytesMatch) {
     const [_type, size] = bytesMatch
-    if (Number.parseInt(size) !== ((value as Hex).length - 2) / 2)
+    if (Number.parseInt(size, 10) !== ((value as Hex).length - 2) / 2)
       throw new BytesSizeMismatchError({
-        expectedSize: Number.parseInt(size),
+        expectedSize: Number.parseInt(size, 10),
         givenSize: ((value as Hex).length - 2) / 2,
       })
     return pad(value as Hex, { dir: 'right', size: isArray ? 32 : null }) as Hex

package/utils/abi/getAbiItem.ts

@@ -102,7 +102,7 @@ export function getAbiItem<
   if (abiItems.length === 1)
     return abiItems[0] as GetAbiItemReturnType<abi, name, args>
 
-  let matchedAbiItem: AbiItem | undefined = undefined
+  let matchedAbiItem: AbiItem | undefined
   for (const abiItem of abiItems) {
     if (!('inputs' in abiItem)) continue
     if (!args || args.length === 0) {

package/utils/abi/prepareEncodeFunctionData.ts

@@ -9,19 +9,18 @@ import {
   AbiFunctionNotFoundError,
   type AbiFunctionNotFoundErrorType,
 } from '../../errors/abi.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type {
   ContractFunctionArgs,
   ContractFunctionName,
 } from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import type { ConcatHexErrorType } from '../data/concat.js'
 import {
   type ToFunctionSelectorErrorType,
   toFunctionSelector,
 } from '../hash/toFunctionSelector.js'
-
-import type { ErrorType } from '../../errors/utils.js'
-import type { Hex } from '../../types/misc.js'
-import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
 import { type FormatAbiItemErrorType, formatAbiItem } from './formatAbiItem.js'
 import { type GetAbiItemErrorType, getAbiItem } from './getAbiItem.js'
 

package/utils/address/getContractAddress.ts

@@ -1,5 +1,5 @@
 import type { Address } from 'abitype'
-
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 import { type ConcatErrorType, concat } from '../data/concat.js'
 import { type IsBytesErrorType, isBytes } from '../data/isBytes.js'
@@ -8,8 +8,6 @@ import { type SliceErrorType, slice } from '../data/slice.js'
 import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
 import { type ToRlpErrorType, toRlp } from '../encoding/toRlp.js'
 import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
-
-import type { ErrorType } from '../../errors/utils.js'
 import { type GetAddressErrorType, getAddress } from './getAddress.js'
 
 export type GetCreateAddressOptions = {

package/utils/buildRequest.ts

@@ -7,10 +7,10 @@ import {
   type WebSocketRequestErrorType,
 } from '../errors/request.js'
 import {
-  AtomicReadyWalletRejectedUpgradeError,
-  type AtomicReadyWalletRejectedUpgradeErrorType,
   AtomicityNotSupportedError,
   type AtomicityNotSupportedErrorType,
+  AtomicReadyWalletRejectedUpgradeError,
+  type AtomicReadyWalletRejectedUpgradeErrorType,
   BundleTooLargeError,
   type BundleTooLargeErrorType,
   ChainDisconnectedError,
@@ -250,7 +250,7 @@ export function buildRequest<request extends (args: any) => Promise<any>>(
               if (error && error instanceof HttpRequestError) {
                 const retryAfter = error?.headers?.get('Retry-After')
                 if (retryAfter?.match(/\d/))
-                  return Number.parseInt(retryAfter) * 1000
+                  return Number.parseInt(retryAfter, 10) * 1000
               }
 
               // Otherwise, let's retry with an exponential backoff.

package/utils/ccip.ts

@@ -1,6 +1,7 @@
 import type { Abi, Address } from 'abitype'
 
 import { type CallParameters, call } from '../actions/public/call.js'
+import type { Client } from '../clients/createClient.js'
 import type { Transport } from '../clients/transports/createTransport.js'
 import type { BaseError } from '../errors/base.js'
 import {
@@ -14,11 +15,9 @@ import {
   HttpRequestError,
   type HttpRequestErrorType,
 } from '../errors/request.js'
+import type { ErrorType } from '../errors/utils.js'
 import type { Chain } from '../types/chain.js'
 import type { Hex } from '../types/misc.js'
-
-import type { Client } from '../clients/createClient.js'
-import type { ErrorType } from '../errors/utils.js'
 import { decodeErrorResult } from './abi/decodeErrorResult.js'
 import { encodeAbiParameters } from './abi/encodeAbiParameters.js'
 import { isAddressEqual } from './address/isAddressEqual.js'

package/utils/encoding/fromBytes.ts

@@ -5,9 +5,9 @@ import { type TrimErrorType, trim } from '../data/trim.js'
 
 import {
   type AssertSizeErrorType,
+  assertSize,
   type HexToBigIntErrorType,
   type HexToNumberErrorType,
-  assertSize,
   hexToBigInt,
   hexToNumber,
 } from './fromHex.js'

package/utils/ens/avatar/parseAvatarRecord.ts

@@ -8,14 +8,14 @@ import {
   type GetJsonImageErrorType,
   type GetMetadataAvatarUriErrorType,
   type GetNftTokenUriErrorType,
-  type ParseAvatarUriErrorType,
-  type ParseNftUriErrorType,
-  type ResolveAvatarUriErrorType,
   getJsonImage,
   getMetadataAvatarUri,
   getNftTokenUri,
+  type ParseAvatarUriErrorType,
+  type ParseNftUriErrorType,
   parseAvatarUri,
   parseNftUri,
+  type ResolveAvatarUriErrorType,
   resolveAvatarUri,
 } from './utils.js'
 

package/utils/ens/avatar/utils.ts

@@ -27,7 +27,7 @@ type UriItem = {
 }
 
 const networkRegex =
-  /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/
+  /(?<protocol>https?:\/\/[^/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/
 const ipfsHashRegex =
   /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/
 const base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/
@@ -51,8 +51,7 @@ export async function isImageUri(uri: string) {
       return false
     }
     // fail in NodeJS, since the error is not cors but any other network issue
-    // biome-ignore lint/suspicious/noPrototypeBuiltins:
-    if (!globalThis.hasOwnProperty('Image')) return false
+    if (!Object.hasOwn(globalThis, 'Image')) return false
     // in case of cors, use image api to validate if given url is an actual image
     return new Promise((resolve) => {
       const img = new Image()
@@ -246,7 +245,7 @@ export function parseNftUri(uri_: string): ParsedNft {
     throw new EnsAvatarInvalidNftUriError({ reason: 'ERC namespace not found' })
 
   return {
-    chainID: Number.parseInt(chainID),
+    chainID: Number.parseInt(chainID, 10),
     namespace: erc_namespace.toLowerCase(),
     contractAddress: contractAddress as Address,
     tokenID,

package/utils/ens/namehash.ts

@@ -3,8 +3,8 @@ import type { ByteArray } from '../../types/misc.js'
 import { type ConcatErrorType, concat } from '../data/concat.js'
 import {
   type StringToBytesErrorType,
-  type ToBytesErrorType,
   stringToBytes,
+  type ToBytesErrorType,
   toBytes,
 } from '../encoding/toBytes.js'
 import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'

package/utils/filters/createFilterRequestScope.ts

@@ -2,8 +2,7 @@ import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { OnResponseFn } from '../../clients/transports/fallback.js'
 import type { Chain } from '../../types/chain.js'
-import type { PublicRpcSchema } from '../../types/eip1193.js'
-import type { EIP1193RequestFn } from '../../types/eip1193.js'
+import type { EIP1193RequestFn, PublicRpcSchema } from '../../types/eip1193.js'
 import type { Hex } from '../../types/misc.js'
 import type { Filter } from '../../types/utils.js'
 

package/utils/formatters/block.ts

@@ -1,7 +1,7 @@
 import type { ErrorType } from '../../errors/utils.js'
 import type { Block, BlockTag } from '../../types/block.js'
-import type { Chain } from '../../types/chain.js'
 import type {
+  Chain,
   ExtractChainFormatterExclude,
   ExtractChainFormatterReturnType,
 } from '../../types/chain.js'

package/utils/formatters/transaction.ts

@@ -1,8 +1,8 @@
 import type { ErrorType } from '../../errors/utils.js'
 import type { SignedAuthorizationList } from '../../types/authorization.js'
 import type { BlockTag } from '../../types/block.js'
-import type { Chain } from '../../types/chain.js'
 import type {
+  Chain,
   ExtractChainFormatterExclude,
   ExtractChainFormatterReturnType,
 } from '../../types/chain.js'

package/utils/hash/hashSignature.ts

@@ -1,6 +1,5 @@
-import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
-
 import type { ErrorType } from '../../errors/utils.js'
+import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
 import { type Keccak256ErrorType, keccak256 } from './keccak256.js'
 
 const hash = (value: string) => keccak256(toBytes(value))