viem 0.4.0-main.20230418T011420 → 0.4.0-main.20230419T210450

package/src/utils/encoding/toBytes.ts

@@ -1,62 +1,192 @@
 import { BaseError } from '../../errors/index.js'
 import type { ByteArray, Hex } from '../../types/index.js'
 import { isHex } from '../data/isHex.js'
+import { pad } from '../data/pad.js'
+import { assertSize } from './fromHex.js'
 import type { NumberToHexOpts } from './toHex.js'
 import { numberToHex } from './toHex.js'
 
 const encoder = new TextEncoder()
 
-/** @description Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array. */
+export type ToBytesParameters = {
+  /** Size of the output bytes. */
+  size?: number
+}
+
+/**
+ * Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html
+ * - Example: https://viem.sh/docs/utilities/toBytes.html#usage
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes('Hello world')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes(420)
+ * // Uint8Array([1, 164])
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes(420, { size: 4 })
+ * // Uint8Array([0, 0, 1, 164])
+ */
 export function toBytes(
   value: string | bigint | number | boolean | Hex,
+  opts: ToBytesParameters = {},
 ): ByteArray {
   if (typeof value === 'number' || typeof value === 'bigint')
-    return numberToBytes(value)
-  if (typeof value === 'boolean') return boolToBytes(value)
-  if (isHex(value)) return hexToBytes(value)
-  return stringToBytes(value)
+    return numberToBytes(value, opts)
+  if (typeof value === 'boolean') return boolToBytes(value, opts)
+  if (isHex(value)) return hexToBytes(value, opts)
+  return stringToBytes(value, opts)
+}
+
+export type BoolToHexOpts = {
+  /** Size of the output bytes. */
+  size?: number
 }
 
 /**
- * @description Encodes a boolean into a byte array.
+ * Encodes a boolean into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html#booltobytes
+ *
+ * @param value Boolean value to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { boolToBytes } from 'viem'
+ * const data = boolToBytes(true)
+ * // Uint8Array([1])
+ *
+ * @example
+ * import { boolToBytes } from 'viem'
+ * const data = boolToBytes(true, { size: 32 })
+ * // Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
  */
-export function boolToBytes(value: boolean) {
+export function boolToBytes(value: boolean, opts: BoolToHexOpts = {}) {
   const bytes = new Uint8Array(1)
   bytes[0] = Number(value)
+  if (typeof opts.size === 'number') {
+    assertSize(bytes, { size: opts.size })
+    return pad(bytes, { size: opts.size })
+  }
   return bytes
 }
 
+export type HexToBytesOpts = {
+  /** Size of the output bytes. */
+  size?: number
+}
+
 /**
- * @description Encodes a hex string into a byte array.
+ * Encodes a hex string into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html#hextobytes
+ *
+ * @param hex Hex string to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { hexToBytes } from 'viem'
+ * const data = hexToBytes('0x48656c6c6f20776f726c6421')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { hexToBytes } from 'viem'
+ * const data = hexToBytes('0x48656c6c6f20776f726c6421', { size: 32 })
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
  */
-export function hexToBytes(hex_: Hex): ByteArray {
-  let hex = hex_.slice(2) as string
+export function hexToBytes(hex_: Hex, opts: HexToBytesOpts = {}): ByteArray {
+  let hex = hex_
+  if (opts.size) {
+    assertSize(hex, { size: opts.size })
+    hex = pad(hex, { dir: 'right', size: opts.size })
+  }
 
-  if (hex.length % 2) hex = `0${hex}`
+  let hexString = hex.slice(2) as string
+  if (hexString.length % 2) hexString = `0${hexString}`
 
-  const bytes = new Uint8Array(hex.length / 2)
+  const bytes = new Uint8Array(hexString.length / 2)
   for (let index = 0; index < bytes.length; index++) {
     const start = index * 2
-    const hexByte = hex.slice(start, start + 2)
+    const hexByte = hexString.slice(start, start + 2)
     const byte = Number.parseInt(hexByte, 16)
     if (Number.isNaN(byte) || byte < 0)
-      throw new BaseError(`Invalid byte sequence ("${hexByte}" in "${hex}").`)
+      throw new BaseError(
+        `Invalid byte sequence ("${hexByte}" in "${hexString}").`,
+      )
     bytes[index] = byte
   }
   return bytes
 }
 
 /**
- * @description Encodes a number into a byte array.
+ * Encodes a number into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html#numbertobytes
+ *
+ * @param value Number to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { numberToBytes } from 'viem'
+ * const data = numberToBytes(420)
+ * // Uint8Array([1, 164])
+ *
+ * @example
+ * import { numberToBytes } from 'viem'
+ * const data = numberToBytes(420, { size: 4 })
+ * // Uint8Array([0, 0, 1, 164])
  */
 export function numberToBytes(value: bigint | number, opts?: NumberToHexOpts) {
   const hex = numberToHex(value, opts)
   return hexToBytes(hex)
 }
 
+export type StringToBytesOpts = {
+  /** Size of the output bytes. */
+  size?: number
+}
+
 /**
- * @description Encodes a UTF-8 string into a byte array.
+ * Encodes a UTF-8 string into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html#stringtobytes
+ *
+ * @param value String to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { stringToBytes } from 'viem'
+ * const data = stringToBytes('Hello world!')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { stringToBytes } from 'viem'
+ * const data = stringToBytes('Hello world!', { size: 32 })
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
  */
-export function stringToBytes(value: string): ByteArray {
-  return encoder.encode(value)
+export function stringToBytes(
+  value: string,
+  opts: StringToBytesOpts = {},
+): ByteArray {
+  const bytes = encoder.encode(value)
+  if (typeof opts.size === 'number') {
+    assertSize(bytes, { size: opts.size })
+    return pad(bytes, { dir: 'right', size: opts.size })
+  }
+  return bytes
 }

package/src/utils/encoding/toHex.ts

@@ -1,58 +1,162 @@
 import { pad } from '../data/index.js'
 import type { ByteArray, Hex } from '../../types/index.js'
 import { IntegerOutOfRangeError } from '../../errors/index.js'
+import { assertSize } from './fromHex.js'
 
 const hexes = Array.from({ length: 256 }, (_v, i) =>
   i.toString(16).padStart(2, '0'),
 )
 
+export type ToHexParameters = {
+  /** The size (in bytes) of the output hex value. */
+  size?: number
+}
+
 /**
- * @description Encodes a boolean into a hex string
+ * Encodes a string, number, bigint, or ByteArray into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html
+ * - Example: https://viem.sh/docs/utilities/toHex.html#usage
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex('Hello world')
+ * // '0x48656c6c6f20776f726c6421'
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex(420)
+ * // '0x1a4'
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex('Hello world', { size: 32 })
+ * // '0x48656c6c6f20776f726c64210000000000000000000000000000000000000000'
  */
-export function boolToHex(value: boolean): Hex {
-  return `0x${Number(value)}`
+export function toHex(
+  value: string | number | bigint | boolean | ByteArray,
+  opts: ToHexParameters = {},
+): Hex {
+  if (typeof value === 'number' || typeof value === 'bigint')
+    return numberToHex(value, opts)
+  if (typeof value === 'string') {
+    return stringToHex(value, opts)
+  }
+  if (typeof value === 'boolean') return boolToHex(value, opts)
+  return bytesToHex(value, opts)
+}
+
+export type BoolToHexOpts = {
+  /** The size (in bytes) of the output hex value. */
+  size?: number
 }
 
 /**
- * @description Encodes a bytes array into a hex string
+ * Encodes a boolean into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html#booltohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(true)
+ * // '0x1'
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(false)
+ * // '0x0'
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(true, { size: 32 })
+ * // '0x0000000000000000000000000000000000000000000000000000000000000001'
  */
-export function bytesToHex(value: ByteArray): Hex {
-  let hex = ''
-  for (let i = 0; i < value.length; i++) {
-    hex += hexes[value[i]]
+export function boolToHex(value: boolean, opts: BoolToHexOpts = {}): Hex {
+  const hex: Hex = `0x${Number(value)}`
+  if (typeof opts.size === 'number') {
+    assertSize(hex, { size: opts.size })
+    return pad(hex, { size: opts.size })
   }
-  return `0x${hex}`
+  return hex
+}
+
+export type BytesToHexOpts = {
+  /** The size (in bytes) of the output hex value. */
+  size?: number
 }
 
 /**
- * @description Encodes a string, number, bigint, or ByteArray into a hex string
+ * Encodes a bytes array into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html#bytestohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { bytesToHex } from 'viem'
+ * const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ * // '0x48656c6c6f20576f726c6421'
+ *
+ * @example
+ * import { bytesToHex } from 'viem'
+ * const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]), { size: 32 })
+ * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
  */
-export function toHex(
-  value: string | number | bigint | boolean | ByteArray,
-): Hex {
-  if (typeof value === 'number' || typeof value === 'bigint')
-    return numberToHex(value)
-  if (typeof value === 'string') {
-    return stringToHex(value)
+export function bytesToHex(value: ByteArray, opts: BytesToHexOpts = {}): Hex {
+  let hexString = ''
+  for (let i = 0; i < value.length; i++) {
+    hexString += hexes[value[i]]
+  }
+
+  const hex: Hex = `0x${hexString}`
+  if (typeof opts.size === 'number') {
+    assertSize(hex, { size: opts.size })
+    return pad(hex, { dir: 'right', size: opts.size })
   }
-  if (typeof value === 'boolean') return boolToHex(value)
-  return bytesToHex(value)
+  return hex
 }
 
 export type NumberToHexOpts =
   | {
-      // Whether or not the number of a signed representation.
+      /** Whether or not the number of a signed representation. */
       signed?: boolean
-      // The size of the output hex (in bytes).
+      /** The size (in bytes) of the output hex value. */
       size: number
     }
   | {
       signed?: never
-      size?: never
+      /** The size (in bytes) of the output hex value. */
+      size?: number
     }
 
 /**
- * @description Encodes a number or bigint into a hex string
+ * Encodes a number or bigint into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html#numbertohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { numberToHex } from 'viem'
+ * const data = numberToHex(420)
+ * // '0x1a4'
+ *
+ * @example
+ * import { numberToHex } from 'viem'
+ * const data = numberToHex(420, { size: 32 })
+ * // '0x00000000000000000000000000000000000000000000000000000000000001a4'
  */
 export function numberToHex(
   value_: number | bigint,
@@ -91,12 +195,33 @@ export function numberToHex(
   return hex
 }
 
+export type StringToHexOpts = {
+  /** The size (in bytes) of the output hex value. */
+  size?: number
+}
+
 const encoder = new TextEncoder()
 
 /**
- * @description Encodes a UTF-8 string into a hex string
+ * Encodes a UTF-8 string into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html#stringtohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { stringToHex } from 'viem'
+ * const data = stringToHex('Hello World!')
+ * // '0x48656c6c6f20576f726c6421'
+ *
+ * @example
+ * import { stringToHex } from 'viem'
+ * const data = stringToHex('Hello World!', { size: 32 })
+ * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
  */
-export function stringToHex(value_: string): Hex {
+export function stringToHex(value_: string, opts: StringToHexOpts = {}): Hex {
   const value = encoder.encode(value_)
-  return toHex(value)
+  return bytesToHex(value, opts)
 }

package/src/utils/errors/getContractError.ts

@@ -33,11 +33,12 @@ export function getContractError(
     sender?: Address
   },
 ) {
-  const { code, data, message } = (
+  const { code, data, message, shortMessage } = (
     err instanceof RawContractError
       ? err
-      : err instanceof CallExecutionError ||
-        err instanceof EstimateGasExecutionError
+      : !(err.cause && 'data' in (err.cause as BaseError)) &&
+        (err instanceof CallExecutionError ||
+          err instanceof EstimateGasExecutionError)
       ? ((err.cause as BaseError)?.cause as BaseError)?.cause || {}
       : err.cause || {}
   ) as RawContractError
@@ -45,12 +46,15 @@ export function getContractError(
   let cause = err
   if (err instanceof AbiDecodingZeroDataError) {
     cause = new ContractFunctionZeroDataError({ functionName })
-  } else if (code === EXECUTION_REVERTED_ERROR_CODE && (data || message)) {
+  } else if (
+    code === EXECUTION_REVERTED_ERROR_CODE &&
+    (data || message || shortMessage)
+  ) {
     cause = new ContractFunctionRevertedError({
       abi,
       data,
       functionName,
-      message,
+      message: shortMessage ?? message,
     })
   }
 

package/src/utils/promise/createBatchScheduler.ts

@@ -0,0 +1,82 @@
+type Resolved<TReturnType extends readonly unknown[] = any> = [
+  result: TReturnType[number],
+  results: TReturnType,
+]
+
+type PendingPromise<TReturnType extends readonly unknown[] = any> = {
+  resolve?: (data: Resolved<TReturnType>) => void
+  reject?: (reason?: unknown) => void
+}
+
+type SchedulerItem = { args: unknown; pendingPromise: PendingPromise }
+
+const schedulerCache = new Map<number | string, SchedulerItem[]>()
+
+export function createBatchScheduler<
+  TParameters,
+  TReturnType extends readonly unknown[],
+>({
+  fn,
+  id,
+  shouldSplitBatch,
+  wait = 0,
+}: {
+  fn: (args: TParameters[]) => Promise<TReturnType>
+  id: number | string
+  shouldSplitBatch?: (args: TParameters[]) => boolean
+  wait?: number
+}) {
+  const exec = async () => {
+    const scheduler = getScheduler()
+    flush()
+
+    const args = scheduler.map(({ args }) => args)
+
+    if (args.length === 0) return
+
+    fn(args as TParameters[])
+      .then((data) => {
+        scheduler.forEach(({ pendingPromise }, i) =>
+          pendingPromise.resolve?.([data[i], data]),
+        )
+      })
+      .catch((err) => {
+        scheduler.forEach(({ pendingPromise }) => pendingPromise.reject?.(err))
+      })
+  }
+
+  const flush = () => schedulerCache.delete(id)
+
+  const getBatchedArgs = () =>
+    getScheduler().map(({ args }) => args) as TParameters[]
+
+  const getScheduler = () => schedulerCache.get(id) || []
+
+  const setScheduler = (item: SchedulerItem) =>
+    schedulerCache.set(id, [...getScheduler(), item])
+
+  return {
+    flush,
+    async schedule(args: TParameters) {
+      const pendingPromise: PendingPromise<TReturnType> = {}
+      const promise = new Promise<Resolved<TReturnType>>((resolve, reject) => {
+        pendingPromise.resolve = resolve
+        pendingPromise.reject = reject
+      })
+
+      const split = shouldSplitBatch?.([...getBatchedArgs(), args])
+
+      if (split) exec()
+
+      const hasActiveScheduler = getScheduler().length > 0
+      if (hasActiveScheduler) {
+        setScheduler({ args, pendingPromise })
+        return promise
+      }
+
+      setScheduler({ args, pendingPromise })
+      setTimeout(exec, wait)
+      return promise
+    },
+  }
+}

package/src/utils/promise/index.ts

@@ -1,3 +1,4 @@
+export { createBatchScheduler } from './createBatchScheduler.js'
 export { getCache, withCache } from './withCache.js'
 export { withRetry } from './withRetry.js'
 export { withTimeout } from './withTimeout.js'