viem 0.2.11 → 0.2.13

package/src/types/typedData.ts

@@ -0,0 +1,81 @@
+import type {
+  Narrow,
+  TypedData,
+  TypedDataDomain,
+  TypedDataToPrimitiveTypes,
+} from 'abitype'
+
+export type TypedDataDefinition<
+  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
+  TPrimaryType extends string = string,
+> = {
+  primaryType: GetTypedDataPrimaryType<TTypedData, TPrimaryType>
+} & GetTypedDataMessage<TTypedData, TPrimaryType> &
+  GetTypedDataTypes<TTypedData, TPrimaryType> &
+  GetTypedDataDomain<TTypedData, TPrimaryType>
+
+export type GetTypedDataDomain<
+  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
+  TPrimaryType extends string = string,
+  TSchema = TTypedData extends TypedData
+    ? TypedDataToPrimitiveTypes<TTypedData>
+    : { [key: string]: any },
+  TDomain = TSchema extends { EIP712Domain: infer Domain }
+    ? Domain
+    : TypedDataDomain,
+> = TPrimaryType extends 'EIP712Domain'
+  ? {
+      domain: TDomain
+    }
+  : {
+      domain?: TDomain
+    }
+
+export type GetTypedDataMessage<
+  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
+  TPrimaryType extends string = string,
+  TSchema = TTypedData extends TypedData
+    ? TypedDataToPrimitiveTypes<TTypedData>
+    : { [key: string]: any },
+  TMessage = TSchema[TPrimaryType extends keyof TSchema
+    ? TPrimaryType
+    : keyof TSchema],
+> = TPrimaryType extends 'EIP712Domain'
+  ? {}
+  : { [key: string]: any } extends TMessage // Check if we were able to infer the shape of typed data
+  ? {
+      /**
+       * Data to sign
+       *
+       * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link types} for type inference.
+       */
+      message: { [key: string]: unknown }
+    }
+  : {
+      /** Data to sign */
+      message: TMessage
+    }
+
+export type GetTypedDataPrimaryType<
+  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
+  TPrimaryType extends string = string,
+> = TTypedData extends TypedData
+  ? keyof TTypedData extends infer AbiFunctionNames
+    ?
+        | AbiFunctionNames
+        | (TPrimaryType extends AbiFunctionNames ? TPrimaryType : never)
+        | (TypedData extends TTypedData ? string : never)
+        | 'EIP712Domain'
+    : never
+  : TPrimaryType
+
+export type GetTypedDataTypes<
+  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
+  TPrimaryType extends string = string,
+> = TPrimaryType extends 'EIP712Domain'
+  ? {
+      types?: Narrow<TTypedData>
+    }
+  : {
+      types: Narrow<TTypedData>
+    }

package/src/types/utils.ts

@@ -0,0 +1,203 @@
+/**
+ * Filters out all members of {@link T} that are not {@link P}
+ *
+ * @param T - Items to filter
+ * @param P - Type to filter out
+ * @returns Filtered items
+ *
+ * @example
+ * type Result = Filter<['a', 'b', 'c'], 'b'>
+ * //   ^? type Result = ['a', 'c']
+ */
+export type Filter<
+  T extends readonly unknown[],
+  P,
+  Acc extends readonly unknown[] = [],
+> = T extends readonly [infer F, ...infer Rest extends readonly unknown[]]
+  ? [F] extends [P]
+    ? Filter<Rest, P, [...Acc, F]>
+    : Filter<Rest, P, Acc>
+  : readonly [...Acc]
+
+/**
+ * @description Checks if {@link T} can be narrowed further than {@link U}
+ * @param T - Type to check
+ * @param U - Type to against
+ * @example
+ * type Result = IsNarrowable<'foo', string>
+ * //   ^? true
+ */
+export type IsNarrowable<T, U> = IsNever<
+  (T extends U ? true : false) & (U extends T ? false : true)
+> extends true
+  ? false
+  : true
+
+/**
+ * @description Checks if {@link T} is `never`
+ * @param T - Type to check
+ * @example
+ * type Result = IsNever<never>
+ * //   ^? type Result = true
+ */
+export type IsNever<T> = [T] extends [never] ? true : false
+
+/**
+ * @description Evaluates boolean "or" condition for {@link T} properties.
+ * @param T - Type to check
+ *
+ * * @example
+ * type Result = Or<[false, true, false]>
+ * //   ^? type Result = true
+ *
+ * @example
+ * type Result = Or<[false, false, false]>
+ * //   ^? type Result = false
+ */
+export type Or<T extends readonly unknown[],> = T extends readonly [
+  infer Head,
+  ...infer Tail,
+]
+  ? Head extends true
+    ? true
+    : Or<Tail>
+  : false
+
+/**
+ * @description Checks if {@link T} is `undefined`
+ * @param T - Type to check
+ * @example
+ * type Result = IsUndefined<undefined>
+ * //   ^? type Result = true
+ */
+export type IsUndefined<T> = [undefined] extends [T] ? true : false
+
+/**
+ * Excludes empty attributes from T if TMaybeExclude is true.
+ *
+ * @example
+ * type Result = MaybeExcludeEmpty<{ a: string, b: number, c: [] }, true>
+ * //   ^? type Result = { a: string, b: number }
+ * @example
+ * type Result = MaybeExcludeEmpty<{ a: string, b: number, c: [] }, false>
+ * //   ^? type Result = { a: string, b: number, c: [] }
+ * @example
+ * type Result = MaybeExcludeEmpty<{ a: string, b: number, c: undefined }, true>
+ * //   ^? type Result = { a: string, b: number }
+ */
+export type MaybeExcludeEmpty<
+  T,
+  TMaybeExclude extends boolean,
+> = TMaybeExclude extends true ? Exclude<T, [] | null | undefined> : T
+
+export type MaybePromise<T> = T | Promise<T>
+
+/**
+ * @description Makes attributes on the type T required if TRequired is true.
+ *
+ * @example
+ * MaybeRequired<{ a: string, b?: number }, true>
+ * => { a: string, b: number }
+ *
+ * MaybeRequired<{ a: string, b?: number }, false>
+ * => { a: string, b?: number }
+ */
+export type MaybeRequired<T, TRequired extends boolean> = TRequired extends true
+  ? Required<T>
+  : T
+
+/**
+ * @description Merges the intersection properties of T and U.
+ *
+ * @example
+ * MergeIntersectionProperties<{ a: string, b: number }, { a: number, c: boolean }>
+ * => { a: number, b: number }
+ */
+export type MergeIntersectionProperties<T, U> = {
+  [K in
+    keyof T as K extends keyof U
+      ? U[K] extends void
+        ? never
+        : K
+      : K]: K extends keyof U ? U[K] : T[K]
+}
+
+/**
+ * @description Makes nullable properties from T optional.
+ *
+ * @example
+ * OptionalNullable<{ a: string | undefined, c: number }>
+ * => { a?: string | undefined, c: number }
+ */
+export type OptionalNullable<T> = {
+  [K in keyof T as T[K] extends NonNullable<unknown> ? K : never]: T[K]
+} & {
+  [K in keyof T as T[K] extends NonNullable<unknown> ? never : K]?: T[K]
+}
+
+/**
+ * @description Constructs a type by excluding `undefined` from `T`.
+ *
+ * @example
+ * NoUndefined<string | undefined>
+ * => string
+ */
+export type NoUndefined<T> = T extends undefined ? never : T
+
+/**
+ * @description Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * PartialBy<{ a: string, b: number }, 'a'>
+ * => { a?: string, b: number }
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
+
+/**
+ * @description Combines members of an intersection into a readable type.
+ *
+ * @link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
+ * @example
+ * Prettify<{ a: string } | { b: string } | { c: number, d: bigint }>
+ * => { a: string, b: string, c: number, d: bigint }
+ */
+export type Prettify<T> = {
+  [K in keyof T]: T[K]
+} & {}
+
+type TrimLeft<T, Chars extends string = ' '> = T extends `${Chars}${infer R}`
+  ? TrimLeft<R>
+  : T
+type TrimRight<T, Chars extends string = ' '> = T extends `${infer R}${Chars}`
+  ? TrimRight<R>
+  : T
+
+/**
+ * @description Creates a type with required keys K from T.
+ *
+ * @example
+ * type Result = RequiredBy<{ a?: string, b?: number, c: number }, 'a' | 'c'>
+ * //   ^? { a: string, b?: number, c: number }
+ */
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>
+
+/**
+ * @description Trims empty space from type T.
+ *
+ * @example
+ * Trim<'      lol  '>
+ * => 'lol'
+ */
+export type Trim<T, Chars extends string = ' '> = TrimLeft<
+  TrimRight<T, Chars>,
+  Chars
+>
+
+/**
+ * @description Creates a type that extracts the values of T.
+ *
+ * @example
+ * ValueOf<{ a: string, b: number }>
+ * => string | number
+ */
+export type ValueOf<T> = T[keyof T]

package/src/types/window.ts

@@ -0,0 +1,9 @@
+import type { Events, Requests } from './eip1193.js'
+
+type WindowProvider = Requests & Events
+
+declare global {
+  interface Window {
+    ethereum?: WindowProvider
+  }
+}

package/src/utils/abi/decodeAbiParameters.ts

@@ -0,0 +1,312 @@
+import type {
+  AbiParameter,
+  AbiParametersToPrimitiveTypes,
+  AbiParameterToPrimitiveType,
+  Narrow,
+} from 'abitype'
+
+import {
+  AbiDecodingDataSizeInvalidError,
+  AbiDecodingDataSizeTooSmallError,
+  AbiDecodingZeroDataError,
+  InvalidAbiDecodingTypeError,
+} from '../../errors/index.js'
+import type { Hex } from '../../types/index.js'
+import { checksumAddress } from '../address/index.js'
+import { size, slice, trim } from '../data/index.js'
+import {
+  hexToBigInt,
+  hexToBool,
+  hexToNumber,
+  hexToString,
+} from '../encoding/index.js'
+import { getArrayComponents } from './encodeAbiParameters.js'
+
+export type DecodeAbiParametersReturnType<
+  TParams extends
+    | readonly AbiParameter[]
+    | readonly unknown[] = readonly AbiParameter[],
+> = AbiParametersToPrimitiveTypes<
+  TParams extends readonly AbiParameter[] ? TParams : AbiParameter[]
+>
+
+export function decodeAbiParameters<
+  TParams extends readonly AbiParameter[] | readonly unknown[],
+>(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) })
+  return decodeParams({
+    data,
+    params: params as readonly AbiParameter[],
+  }) as unknown as DecodeAbiParametersReturnType<TParams>
+}
+
+////////////////////////////////////////////////////////////////////
+
+type TupleAbiParameter = AbiParameter & { components: readonly AbiParameter[] }
+
+function decodeParams<TParams extends readonly AbiParameter[]>({
+  data,
+  params,
+}: { data: Hex; params: TParams }) {
+  const decodedValues: unknown[] = []
+  let position = 0
+
+  for (let i = 0; i < params.length; i++) {
+    if (position >= size(data))
+      throw new AbiDecodingDataSizeTooSmallError({
+        data,
+        params,
+        size: size(data),
+      })
+
+    const param = params[i]
+    const { consumed, value } = decodeParam({ data, param, position })
+    decodedValues.push(value)
+    // Step across the data by the amount of data consumed by this parameter.
+    position += consumed
+  }
+
+  return decodedValues as unknown as AbiParametersToPrimitiveTypes<TParams>
+}
+
+function decodeParam({
+  data,
+  param,
+  position,
+}: { data: Hex; param: AbiParameter; position: number }): {
+  consumed: number
+  value: any
+} {
+  const arrayComponents = getArrayComponents(param.type)
+  if (arrayComponents) {
+    const [length, type] = arrayComponents
+    return decodeArray(data, {
+      length,
+      param: { ...param, type: type } as AbiParameter,
+      position,
+    })
+  }
+  if (param.type === 'tuple') {
+    return decodeTuple(data, { param: param as TupleAbiParameter, position })
+  }
+  if (param.type === 'string') {
+    return decodeString(data, { position })
+  }
+  if (param.type.startsWith('bytes')) {
+    return decodeBytes(data, { param, position })
+  }
+
+  const value = slice(data, position, position + 32) as Hex
+  if (param.type.startsWith('uint') || param.type.startsWith('int')) {
+    return decodeNumber(value, { param })
+  }
+  if (param.type === 'address') {
+    return decodeAddress(value)
+  }
+  if (param.type === 'bool') {
+    return decodeBool(value)
+  }
+  throw new InvalidAbiDecodingTypeError(param.type, {
+    docsPath: '/docs/contract/decodeAbiParameters',
+  })
+}
+
+////////////////////////////////////////////////////////////////////
+
+function decodeAddress(value: Hex) {
+  return { consumed: 32, value: checksumAddress(slice(value, -20)) }
+}
+
+function decodeArray<TParam extends AbiParameter>(
+  data: Hex,
+  {
+    param,
+    length,
+    position,
+  }: {
+    param: TParam
+    length: number | null
+    position: number
+  },
+) {
+  // If the length of the array is not known in advance (dynamic array),
+  // 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))
+    // Get the length of the array from the offset.
+    const length = hexToNumber(slice(data, offset, offset + 32))
+
+    let consumed = 0
+    const value: AbiParameterToPrimitiveType<TParam>[] = []
+    for (let i = 0; i < length; ++i) {
+      const decodedChild = decodeParam({
+        data: slice(data, offset + 32),
+        param,
+        position: consumed,
+      })
+      consumed += decodedChild.consumed
+      value.push(decodedChild.value)
+    }
+    return { value, consumed: 32 }
+  }
+
+  // If the length of the array is known in advance,
+  // and the length of an element deeply nested in the array is not known,
+  // we need to decode the offset of the array data.
+  if (hasDynamicChild(param)) {
+    // Get the child type of the array.
+    const arrayComponents = getArrayComponents(param.type)
+    // If the child type is not known, the array is dynamic.
+    const dynamicChild = !arrayComponents?.[0]
+
+    let consumed = 0
+    const value: AbiParameterToPrimitiveType<TParam>[] = []
+    for (let i = 0; i < length; ++i) {
+      const offset = hexToNumber(slice(data, position, position + 32))
+      const decodedChild = decodeParam({
+        data: slice(data, offset),
+        param,
+        position: dynamicChild ? consumed : i * 32,
+      })
+      consumed += decodedChild.consumed
+      value.push(decodedChild.value)
+    }
+    return { value, consumed: 32 }
+  }
+
+  // If the length of the array is known in advance,
+  // and the length of each element in the array is known,
+  // the array data is encoded contiguously after the array.
+  let consumed = 0
+  const value: AbiParameterToPrimitiveType<TParam>[] = []
+  for (let i = 0; i < length; ++i) {
+    const decodedChild = decodeParam({
+      data,
+      param,
+      position: position + consumed,
+    })
+    consumed += decodedChild.consumed
+    value.push(decodedChild.value)
+  }
+  return { value, consumed }
+}
+
+function decodeBool(value: Hex) {
+  return { consumed: 32, value: hexToBool(value) }
+}
+
+function decodeBytes<TParam extends AbiParameter>(
+  data: Hex,
+  { param, position }: { param: TParam; position: number },
+) {
+  const [_, size] = param.type.split('bytes')
+  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))
+    // 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)
+    return { consumed: 32, value }
+  }
+
+  const value = slice(data, position, position + parseInt(size))
+  return { consumed: 32, value }
+}
+
+function decodeNumber<TParam extends AbiParameter>(
+  value: Hex,
+  { param }: { param: TParam },
+) {
+  const signed = param.type.startsWith('int')
+  const size = parseInt(param.type.split('int')[1] || '256')
+  return {
+    consumed: 32,
+    value:
+      size > 48
+        ? hexToBigInt(value, { signed })
+        : hexToNumber(value, { signed }),
+  }
+}
+
+function decodeString(data: Hex, { position }: { position: number }) {
+  const offset = hexToNumber(slice(data, position, position + 32))
+  const length = hexToNumber(slice(data, offset, offset + 32))
+  // 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)),
+  )
+  return { consumed: 32, value }
+}
+
+function decodeTuple<
+  TParam extends AbiParameter & { components: readonly AbiParameter[] },
+>(data: Hex, { param, position }: { param: TParam; position: number }) {
+  // Tuples can have unnamed components (i.e. they are arrays), so we must
+  // determine whether the tuple is named or unnamed. In the case of a named
+  // tuple, the value will be an object where each property is the name of the
+  // component. In the case of an unnamed tuple, the value will be an array.
+  const hasUnnamedChild =
+    param.components.length === 0 || param.components.some(({ name }) => !name)
+
+  // Initialize the value to an object or an array, depending on whether the
+  // tuple is named or unnamed.
+  const value: any = hasUnnamedChild ? [] : {}
+  let consumed = 0
+
+  // 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))
+    // Decode each component of the tuple, starting at the offset.
+    for (let i = 0; i < param.components.length; ++i) {
+      const component = param.components[i]
+      const decodedChild = decodeParam({
+        data: slice(data, offset),
+        param: component,
+        position: consumed,
+      })
+      consumed += decodedChild.consumed
+      value[hasUnnamedChild ? i : component?.name!] = decodedChild.value
+    }
+    return { consumed: 32, value }
+  }
+
+  // If the tuple has static children, we can just decode each component
+  // in sequence.
+  for (let i = 0; i < param.components.length; ++i) {
+    const component = param.components[i]
+    const decodedChild = decodeParam({
+      data,
+      param: component,
+      position: position + consumed,
+    })
+    consumed += decodedChild.consumed
+    value[hasUnnamedChild ? i : component?.name!] = decodedChild.value
+  }
+  return { consumed, value }
+}
+
+function hasDynamicChild(param: AbiParameter) {
+  const { type } = param
+  if (type === 'string') return true
+  if (type === 'bytes') return true
+  if (type.endsWith('[]')) return true
+
+  if (type === 'tuple') return (param as any).components?.some(hasDynamicChild)
+
+  const arrayComponents = getArrayComponents(param.type)
+  if (
+    arrayComponents &&
+    hasDynamicChild({ ...param, type: arrayComponents[1] } as AbiParameter)
+  )
+    return true
+
+  return false
+}

package/src/utils/abi/decodeDeployData.ts

@@ -0,0 +1,45 @@
+import type { Abi } from 'abitype'
+
+import {
+  AbiConstructorNotFoundError,
+  AbiConstructorParamsNotFoundError,
+} from '../../errors/index.js'
+import type { Hex } from '../../types/index.js'
+import { decodeAbiParameters } from './decodeAbiParameters.js'
+
+const docsPath = '/docs/contract/decodeDeployData'
+
+export type DecodeDeployDataParameters<
+  TAbi extends Abi | readonly unknown[] = Abi,
+> = {
+  abi: TAbi
+  bytecode: Hex
+  data: Hex
+}
+export type DecodeDeployDataReturnType = {
+  args?: readonly unknown[] | undefined
+  bytecode: Hex
+}
+
+export function decodeDeployData<TAbi extends Abi | readonly unknown[]>({
+  abi,
+  bytecode,
+  data,
+}: DecodeDeployDataParameters<TAbi>): DecodeDeployDataReturnType {
+  if (data === bytecode) return { bytecode }
+
+  const description = (abi as Abi).find(
+    (x) => 'type' in x && x.type === 'constructor',
+  )
+  if (!description) throw new AbiConstructorNotFoundError({ docsPath })
+  if (!('inputs' in description))
+    throw new AbiConstructorParamsNotFoundError({ docsPath })
+  if (!description.inputs || description.inputs.length === 0)
+    throw new AbiConstructorParamsNotFoundError({ docsPath })
+
+  const args = decodeAbiParameters(
+    description.inputs,
+    `0x${data.replace(bytecode, '')}`,
+  )
+  return { args, bytecode }
+}

package/src/utils/abi/decodeErrorResult.ts

@@ -0,0 +1,44 @@
+import type { Abi } from 'abitype'
+import { solidityError, solidityPanic } from '../../constants/index.js'
+import {
+  AbiDecodingZeroDataError,
+  AbiErrorSignatureNotFoundError,
+} from '../../errors/index.js'
+import type { AbiItem, Hex } from '../../types/index.js'
+import { slice } from '../data/index.js'
+import { getFunctionSelector } from '../hash/index.js'
+import { decodeAbiParameters } from './decodeAbiParameters.js'
+import { formatAbiItem } from './formatAbiItem.js'
+
+export type DecodeErrorResultParameters = { abi?: Abi; data: Hex }
+
+export type DecodeErrorResultReturnType = {
+  abiItem: AbiItem
+  errorName: string
+  args?: readonly unknown[]
+}
+
+export function decodeErrorResult({
+  abi,
+  data,
+}: DecodeErrorResultParameters): DecodeErrorResultReturnType {
+  const signature = slice(data, 0, 4)
+  if (signature === '0x') throw new AbiDecodingZeroDataError()
+
+  const abi_ = [...(abi || []), solidityError, solidityPanic]
+  const abiItem = abi_.find(
+    (x) =>
+      x.type === 'error' && signature === getFunctionSelector(formatAbiItem(x)),
+  )
+  if (!abiItem)
+    throw new AbiErrorSignatureNotFoundError(signature, {
+      docsPath: '/docs/contract/decodeErrorResult',
+    })
+  return {
+    abiItem,
+    args: ('inputs' in abiItem && abiItem.inputs && abiItem.inputs.length > 0
+      ? decodeAbiParameters(abiItem.inputs, slice(data, 4))
+      : undefined) as readonly unknown[] | undefined,
+    errorName: (abiItem as { name: string }).name,
+  }
+}