viem 0.0.0-main.20230518T142520 → 0.0.0-portable-types-20230518183529

package/src/utils/data/isHex.ts

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

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, { strict: false })) return Math.ceil((value.length - 2) / 2)
+  if (isHex(value)) return Math.ceil((value.length - 2) / 2)
   return value.length
 }

package/src/utils/data/slice.ts

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

package/src/utils/data/trim.ts

@@ -27,9 +27,7 @@ export function trim<TValue extends ByteArray | Hex>(
 
   if (typeof hexOrBytes === 'string') {
     if (data.length === 1 && dir === 'right') data = `${data}0`
-    return `0x${
-      data.length % 2 === 1 ? `0${data}` : data
-    }` as TrimReturnType<TValue>
+    return `0x${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('0x01')
+ * const data = hexToBool('0x1')
  * // 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) === '0x00') return false
-  if (trim(hex) === '0x01') return true
+  if (trim(hex) === '0x0') return false
+  if (trim(hex) === '0x1') return true
   throw new InvalidHexBooleanError(hex)
 }
 

package/src/utils/hash/keccak256.ts

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

package/src/utils/promise/createBatchScheduler.ts

@@ -10,25 +10,6 @@ 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<
@@ -39,10 +20,12 @@ export function createBatchScheduler<
   id,
   shouldSplitBatch,
   wait = 0,
-}: CreateBatchSchedulerArguments<
-  TParameters,
-  TReturnType
->): CreateBatchSchedulerReturnType<TParameters, TReturnType> {
+}: {
+  fn: (args: TParameters[]) => Promise<TReturnType>
+  id: number | string
+  shouldSplitBatch?: (args: TParameters[]) => boolean
+  wait?: number
+}) {
   const exec = async () => {
     const scheduler = getScheduler()
     flush()
@@ -95,5 +78,5 @@ export function createBatchScheduler<
       setTimeout(exec, wait)
       return promise
     },
-  } as unknown as CreateBatchSchedulerReturnType<TParameters, TReturnType>
+  }
 }

package/src/utils/rpc.ts

@@ -7,7 +7,6 @@ import {
   WebSocketRequestError,
 } from '../errors/request.js'
 
-import { createBatchScheduler } from './promise/createBatchScheduler.js'
 import { withTimeout } from './promise/withTimeout.js'
 import { stringify } from './stringify.js'
 
@@ -147,70 +146,61 @@ export async function getSocket(url_: string) {
   // If the socket already exists, return it.
   if (socket) return socket
 
-  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)
-      }
+  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
 
-      // Setup event listeners for RPC & subscription responses.
-      webSocket.addEventListener('close', onClose)
-      webSocket.addEventListener('message', onMessage)
+  const webSocket = new WebSocket(url)
 
-      // 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
-        })
-      }
+  // Set up a cache for incoming "synchronous" requests.
+  const requests = new Map<Id, CallbackFn>()
 
-      // Create a new socket instance.
-      socket = Object.assign(webSocket, {
-        requests,
-        subscriptions,
-      })
-      sockets.set(urlKey, socket)
+  // Set up a cache for subscriptions (eth_subscribe).
+  const subscriptions = new Map<Id, CallbackFn>()
 
-      return [socket]
-    },
+  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
+    })
+  }
+
+  // Create a new socket instance.
+  socket = Object.assign(webSocket, {
+    requests,
+    subscriptions,
   })
+  sockets.set(urlKey, socket)
 
-  const [_, [socket_]] = await schedule()
-  return socket_
+  return socket
 }
 
 function webSocket(

package/src/utils/transaction/serializeTransaction.ts

@@ -18,7 +18,6 @@ import type {
 } from '../../types/transaction.js'
 import { isAddress } from '../address/isAddress.js'
 import { concatHex } from '../data/concat.js'
-import { trim } from '../data/trim.js'
 import { toHex } from '../encoding/toHex.js'
 import { type RecursiveArray, toRlp } from '../encoding/toRlp.js'
 
@@ -98,8 +97,8 @@ function serializeTransactionEIP1559(
   if (signature)
     serializedTransaction.push(
       signature.v === 27n ? '0x' : toHex(1), // yParity
-      trim(signature.r),
-      trim(signature.s),
+      signature.r,
+      signature.s,
     )
 
   return concatHex([