viem 0.0.0-portable-types-20230518183529 → 0.0.0-portable-types-20230523145621

package/src/errors/rpc.ts

@@ -1,10 +1,27 @@
+import type { Prettify } from '../types/utils.js'
 import { BaseError } from './base.js'
 import { RpcRequestError } from './request.js'
 
 const unknownErrorCode = -1
 
-type RpcErrorOptions = {
-  code?: number
+export type RpcErrorCode =
+  | -1
+  | -32700 // Parse error
+  | -32600 // Invalid request
+  | -32601 // Method not found
+  | -32602 // Invalid params
+  | -32603 // Internal error
+  | -32000 // Invalid input
+  | -32001 // Resource not found
+  | -32002 // Resource unavailable
+  | -32003 // Transaction rejected
+  | -32004 // Method not supported
+  | -32005 // Limit exceeded
+  | -32006 // JSON-RPC version not supported
+  | -32042 // Method not found
+
+type RpcErrorOptions<TCode extends number = RpcErrorCode> = {
+  code?: TCode
   docsPath?: string
   metaMessages?: string[]
   shortMessage: string
@@ -15,17 +32,13 @@ type RpcErrorOptions = {
  *
  * - EIP https://eips.ethereum.org/EIPS/eip-1474
  */
-export class RpcError extends BaseError {
-  code: number
+export class RpcError<TCode extends number = RpcErrorCode> extends BaseError {
+  override name = 'RpcError'
+  code: TCode
 
   constructor(
     cause: Error,
-    {
-      code = unknownErrorCode,
-      docsPath,
-      metaMessages,
-      shortMessage,
-    }: RpcErrorOptions,
+    { code, docsPath, metaMessages, shortMessage }: RpcErrorOptions<TCode>,
   ) {
     super(shortMessage, {
       cause,
@@ -34,25 +47,39 @@ export class RpcError extends BaseError {
         metaMessages || (cause as { metaMessages?: string[] })?.metaMessages,
     })
     this.name = cause.name
-    this.code = cause instanceof RpcRequestError ? cause.code : code
+    this.code = (
+      cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode
+    ) as TCode
   }
 }
 
+export type ProviderRpcErrorCode =
+  | 4001 // User Rejected Request
+  | 4100 // Unauthorized
+  | 4200 // Unsupported Method
+  | 4900 // Disconnected
+  | 4901 // Chain Disconnected
+  | 4902 // Chain Not Recongnized
+
 /**
  * Error subclass implementing Ethereum Provider errors per EIP-1193.
  *
  * - EIP https://eips.ethereum.org/EIPS/eip-1193
  */
-export class ProviderRpcError<T = undefined> extends RpcError {
+export class ProviderRpcError<
+  T = undefined,
+> extends RpcError<ProviderRpcErrorCode> {
   override name = 'ProviderRpcError'
 
   data?: T
 
   constructor(
     cause: Error,
-    options: RpcErrorOptions & {
-      data?: T
-    },
+    options: Prettify<
+      RpcErrorOptions<ProviderRpcErrorCode> & {
+        data?: T
+      }
+    >,
   ) {
     super(cause, options)
 

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = '0.3.24'
+export const version = '0.3.35'

package/src/index.ts

@@ -23,6 +23,10 @@ export {
   type DeployContractReturnType,
 } from './actions/wallet/deployContract.js'
 export type { DropTransactionParameters } from './actions/test/dropTransaction.js'
+export {
+  type EstimateContractGasParameters,
+  type EstimateContractGasReturnType,
+} from './actions/public/estimateContractGas.js'
 export {
   type EstimateGasParameters,
   type EstimateGasReturnType,
@@ -288,9 +292,11 @@ export {
   ParseRpcError,
   ProviderDisconnectedError,
   ProviderRpcError,
+  type ProviderRpcErrorCode,
   ResourceNotFoundRpcError,
   ResourceUnavailableRpcError,
   RpcError,
+  type RpcErrorCode,
   TransactionRejectedRpcError,
   SwitchChainError,
   UnauthorizedProviderError,
@@ -436,11 +442,10 @@ export {
 export type { Chain } from './types/chain.js'
 export type {
   EIP1193Provider,
-  RpcErrorCode,
-  RpcError as RpcError_,
+  ProviderRpcError as EIP1193ProviderRpcError,
   ProviderConnectInfo,
   ProviderMessage,
-  Chain as Chain_,
+  AddEthereumChainParameter,
   NetworkSync,
   PublicRequests,
   Requests,

package/src/types/contract.ts

@@ -20,7 +20,7 @@ import type {
 
 import type { Hex, LogTopic } from './misc.js'
 import type { TransactionRequest } from './transaction.js'
-import type { Filter, MaybeRequired, NoUndefined, Prettify } from './utils.js'
+import type { Filter, NoUndefined } from './utils.js'
 
 export type AbiItem = Abi[number]
 
@@ -236,7 +236,10 @@ export type GetEventArgsFromTopics<
   TAbiEvent extends AbiEvent & { type: 'event' } = TAbi extends Abi
     ? ExtractAbiEvent<TAbi, TEventName>
     : AbiEvent & { type: 'event' },
-  TArgs = AbiEventTopicsToPrimitiveTypes<TAbiEvent['inputs'], TTopics, TData>,
+  TArgs = AbiEventParametersToPrimitiveTypes<
+    TAbiEvent['inputs'],
+    { EnableUnion: false; IndexedOnly: false }
+  >,
 > = TTopics extends readonly []
   ? TData extends undefined
     ? { args?: never }
@@ -249,12 +252,10 @@ export type GetEventArgsFromTopics<
 type EventParameterOptions = {
   EnableUnion?: boolean
   IndexedOnly?: boolean
-  Required?: boolean
 }
 type DefaultEventParameterOptions = {
   EnableUnion: true
   IndexedOnly: true
-  Required: false
 }
 
 type HashedEventTypes = 'bytes' | 'string' | 'tuple' | `${string}[${string}]`
@@ -326,13 +327,11 @@ export type AbiEventParametersToPrimitiveTypes<
               >
             },
           ]
-        | (Options['Required'] extends true
-            ? never
-            : // Distribute over tuple to represent optional parameters
-            Filtered extends readonly [
-                ...infer Head extends readonly AbiParameter[],
-                infer _,
-              ]
+        // Distribute over tuple to represent optional parameters
+        | (Filtered extends readonly [
+            ...infer Head extends readonly AbiParameter[],
+            infer _,
+          ]
             ? AbiEventParametersToPrimitiveTypes<
                 readonly [...{ [K in keyof Head]: Omit<Head[K], 'name'> }],
                 Options
@@ -347,81 +346,6 @@ export type AbiEventParametersToPrimitiveTypes<
             ? Name
             : never]?: AbiEventParameterToPrimitiveType<Parameter, Options>
       } extends infer Mapped
-    ? MaybeRequired<
-        Mapped,
-        Options['Required'] extends boolean ? Options['Required'] : false
-      >
+    ? Mapped
     : never
   : never
-
-/**
- * @internal
- */
-// TODO(@tmm): Simplify this type
-export type AbiEventTopicsToPrimitiveTypes<
-  TAbiParameters extends readonly AbiParameter[],
-  TTopics extends LogTopic[] | undefined = undefined,
-  TData extends Hex | undefined = undefined,
-  TBase = TAbiParameters[0] extends { name: string } ? {} : [],
-> = Prettify<
-  TAbiParameters extends readonly [
-    infer Head extends AbiParameter,
-    ...infer Tail,
-  ]
-    ? TTopics extends readonly [infer TopicHead, ...infer TopicTail]
-      ? Head extends { indexed: true }
-        ? Head extends { name: infer Name extends string }
-          ? {
-              [_ in Name]: TopicHead extends LogTopic
-                ? AbiEventTopicToPrimitiveType<Head, TopicHead>
-                : never
-            } & (Tail extends readonly []
-              ? {}
-              : Tail extends readonly AbiParameter[]
-              ? TopicTail extends LogTopic[]
-                ? AbiEventTopicsToPrimitiveTypes<Tail, TopicTail, TData>
-                : {}
-              : {})
-          : [
-              TopicHead extends LogTopic
-                ? AbiEventTopicToPrimitiveType<Head, TopicHead>
-                : never,
-              ...(Tail extends readonly []
-                ? []
-                : Tail extends readonly AbiParameter[]
-                ? TopicTail extends LogTopic[]
-                  ? AbiEventTopicsToPrimitiveTypes<Tail, TopicTail, TData>
-                  : []
-                : []),
-            ]
-        : TBase
-      : TTopics extends readonly []
-      ? TData extends '0x'
-        ? TBase
-        : TData extends Hex
-        ? Head extends AbiParameter
-          ? Head extends { indexed: true }
-            ? Tail extends readonly AbiParameter[]
-              ? AbiEventTopicsToPrimitiveTypes<Tail, [], TData>
-              : TBase
-            : Head extends { name: infer Name extends string }
-            ? {
-                [_ in Name]: AbiParameterToPrimitiveType<Head>
-              } & (Tail extends readonly []
-                ? {}
-                : Tail extends readonly AbiParameter[]
-                ? AbiEventTopicsToPrimitiveTypes<Tail, [], TData>
-                : {})
-            : [
-                AbiParameterToPrimitiveType<Head>,
-                ...(Tail extends readonly []
-                  ? []
-                  : Tail extends readonly AbiParameter[]
-                  ? AbiEventTopicsToPrimitiveTypes<Tail, [], TData>
-                  : []),
-              ]
-          : TBase
-        : TBase
-      : TBase
-    : undefined
->

package/src/types/eip1193.ts

@@ -23,17 +23,11 @@ export type EIP1193Provider = Requests & Events
 //////////////////////////////////////////////////
 // Errors
 
-// rome-ignore format: no formatting
-export type RpcErrorCode =
-  // https://eips.ethereum.org/EIPS/eip-1193#provider-errors
-  | 4_001 | 4_100 | 4_200 | 4_900 | 4_901
-  // https://eips.ethereum.org/EIPS/eip-1474#error-codes
-  | -32700 | -32600 | -32601 | -32602 | -32603 | -32000 | -32001 | -32002 | -32003 | -32004 | -32005 | -32006
-export class RpcError extends Error {
-  code: RpcErrorCode | (number & {})
+export class ProviderRpcError extends Error {
+  code: number
   details: string
 
-  constructor(code: RpcErrorCode | (number & {}), message: string) {
+  constructor(code: number, message: string) {
     super(message)
     this.code = code
     this.details = message
@@ -57,7 +51,7 @@ export type Events = {
     event: 'connect',
     listener: (connectInfo: ProviderConnectInfo) => void,
   ): void
-  on(event: 'disconnect', listener: (error: RpcError) => void): void
+  on(event: 'disconnect', listener: (error: ProviderRpcError) => void): void
   on(event: 'chainChanged', listener: (chainId: string) => void): void
   on(event: 'accountsChanged', listener: (accounts: string[]) => void): void
   on(event: 'message', listener: (message: ProviderMessage) => void): void
@@ -66,7 +60,10 @@ export type Events = {
     event: 'connect',
     listener: (connectInfo: ProviderConnectInfo) => void,
   ): void
-  removeListener(event: 'disconnect', listener: (error: RpcError) => void): void
+  removeListener(
+    event: 'disconnect',
+    listener: (error: ProviderRpcError) => void,
+  ): void
   removeListener(
     event: 'chainChanged',
     listener: (chainId: string) => void,
@@ -84,7 +81,7 @@ export type Events = {
 //////////////////////////////////////////////////
 // Provider Requests
 
-export type Chain = {
+export type AddEthereumChainParameter = {
   /** A 0x-prefixed hexadecimal string */
   chainId: string
   /** The chain name. */
@@ -1034,7 +1031,7 @@ export type WalletRequests = {
      * // => { ... }
      */
     method: 'wallet_addEthereumChain'
-    params: [chain: Chain]
+    params: [chain: AddEthereumChainParameter]
   }): Promise<null>
   request(args: {
     /**

package/src/types/log.ts

@@ -93,7 +93,7 @@ type GetInferredLogValues<
         args: GetEventArgs<
           TAbi,
           TEventName,
-          { EnableUnion: false; IndexedOnly: false; Required: true }
+          { EnableUnion: false; IndexedOnly: false }
         >
         /** The event name decoded from `topics`. */
         eventName: TEventName
@@ -105,7 +105,7 @@ type GetInferredLogValues<
           args: GetEventArgs<
             TAbi,
             string,
-            { EnableUnion: false; IndexedOnly: false; Required: true }
+            { EnableUnion: false; IndexedOnly: false }
           >
           /** The event name decoded from `topics`. */
           eventName: TName

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/buildRequest.ts

@@ -12,9 +12,11 @@ import {
   MethodNotSupportedRpcError,
   ParseRpcError,
   ProviderDisconnectedError,
+  type ProviderRpcErrorCode,
   ResourceNotFoundRpcError,
   ResourceUnavailableRpcError,
   type RpcError,
+  type RpcErrorCode,
   SwitchChainError,
   TransactionRejectedRpcError,
   UnauthorizedProviderError,
@@ -66,7 +68,9 @@ export function buildRequest<TRequest extends (args: any) => Promise<any>>(
         try {
           return await request(args)
         } catch (err_) {
-          const err = err_ as unknown as RpcError
+          const err = err_ as unknown as RpcError<
+            RpcErrorCode | ProviderRpcErrorCode
+          >
           if (err.code === -32700) throw new ParseRpcError(err)
           if (err.code === -32600) throw new InvalidRequestRpcError(err)
           if (err.code === -32601) throw new MethodNotFoundRpcError(err)

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/data/trim.ts

@@ -27,7 +27,9 @@ export function trim<TValue extends ByteArray | Hex>(
 
   if (typeof hexOrBytes === 'string') {
     if (data.length === 1 && dir === 'right') data = `${data}0`
-    return `0x${data}` as TrimReturnType<TValue>
+    return `0x${
+      data.length % 2 === 1 ? `0${data}` : data
+    }` as TrimReturnType<TValue>
   }
   return data as TrimReturnType<TValue>
 }

package/src/utils/encoding/fromHex.ts

@@ -140,7 +140,7 @@ export type HexToBoolOpts = {
  *
  * @example
  * import { hexToBool } from 'viem'
- * const data = hexToBool('0x1')
+ * const data = hexToBool('0x01')
  * // true
  *
  * @example
@@ -154,8 +154,8 @@ export function hexToBool(hex_: Hex, opts: HexToBoolOpts = {}): boolean {
     assertSize(hex, { size: opts.size })
     hex = trim(hex)
   }
-  if (trim(hex) === '0x0') return false
-  if (trim(hex) === '0x1') return true
+  if (trim(hex) === '0x00') return false
+  if (trim(hex) === '0x01') return true
   throw new InvalidHexBooleanError(hex)
 }
 

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>
 }