viem 0.0.0-portable-types-20230518183529 → 0.0.0-portable-types-20230522163654

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

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(

package/src/utils/signature/recoverPublicKey.ts

@@ -18,7 +18,8 @@ export async function recoverPublicKey({
 
   // Derive v = recoveryId + 27 from end of the signature (27 is added when signing the message)
   // The recoveryId represents the y-coordinate on the secp256k1 elliptic curve and can have a value [0, 1].
-  const v = hexToNumber(`0x${signatureHex.slice(130)}`)
+  let v = hexToNumber(`0x${signatureHex.slice(130)}`)
+  if (v === 0 || v === 1) v += 27
 
   const { secp256k1 } = await import('@noble/curves/secp256k1')
   const publicKey = secp256k1.Signature.fromCompact(

package/src/utils/transaction/serializeTransaction.ts

@@ -18,6 +18,7 @@ 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'
 
@@ -97,8 +98,8 @@ function serializeTransactionEIP1559(
   if (signature)
     serializedTransaction.push(
       signature.v === 27n ? '0x' : toHex(1), // yParity
-      signature.r,
-      signature.s,
+      trim(signature.r),
+      trim(signature.s),
     )
 
   return concatHex([

package/test/package.json

@@ -0,0 +1,5 @@
+{
+  "types": "../dist/types/test.d.ts",
+  "module": "../dist/esm/test.js",
+  "main": "../dist/cjs/test.js"
+}

package/utils/package.json

@@ -0,0 +1,5 @@
+{
+  "types": "../dist/types/utils/index.d.ts",
+  "module": "../dist/esm/utils/index.js",
+  "main": "../dist/cjs/utils/index.js"
+}

package/wallet/package.json

@@ -0,0 +1,5 @@
+{
+  "types": "../dist/types/wallet.d.ts",
+  "module": "../dist/esm/wallet.js",
+  "main": "../dist/cjs/wallet.js"
+}

package/window/package.json

@@ -0,0 +1,5 @@
+{
+  "types": "../dist/types/window.d.ts",
+  "module": "../dist/esm/window.js",
+  "main": "../dist/cjs/window.js"
+}