viem 0.0.0-w-20230711215150 → 0.0.0-w-20230720203148

package/src/index.ts

@@ -1,5 +1,10 @@
 export {
   type Abi,
+  type AbiFunction,
+  type AbiParameter,
+  type AbiStateMutability,
+  type AbiParameterKind,
+  type AbiParameterToPrimitiveType,
   type Address,
   type Narrow,
   type ParseAbi,
@@ -502,13 +507,7 @@ export type {
   ExtractFormatterReturnType,
 } from './types/formatter.js'
 export type { Serializers } from './types/serializer.js'
-export type {
-  GetTypedDataDomain,
-  GetTypedDataMessage,
-  GetTypedDataPrimaryType,
-  GetTypedDataTypes,
-  TypedDataDefinition,
-} from './types/typedData.js'
+export type { TypedDataDefinition } from './types/typedData.js'
 export type { GetTransportConfig } from './types/transport.js'
 export type { HDKey } from '@scure/bip32'
 export type { Log } from './types/log.js'

package/src/types/typedData.ts

@@ -1,81 +1,58 @@
+import type { Prettify } from './utils.js'
 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_1: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-  TSchema = TTypedData extends TypedData
-    ? TypedDataToPrimitiveTypes<TTypedData>
-    : { [key_2: string]: any },
-  TDomain = TSchema extends { EIP712Domain: infer Domain }
-    ? Domain
-    : TypedDataDomain,
-> = TPrimaryType extends 'EIP712Domain'
-  ? {
-      domain: TDomain
-    }
-  : {
-      domain?: TDomain
-    }
-
-export type GetTypedDataMessage<
-  TTypedData extends TypedData | { [key_1: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-  TSchema = TTypedData extends TypedData
-    ? TypedDataToPrimitiveTypes<TTypedData>
-    : { [key_2: string]: any },
-  TMessage = TSchema[TPrimaryType extends keyof TSchema
-    ? TPrimaryType
-    : keyof TSchema],
-> = TPrimaryType extends 'EIP712Domain'
-  ? {}
-  : { [key_3: 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_4: string]: unknown }
-    }
-  : {
-      /** Data to sign */
-      message: TMessage
-    }
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+  ///
+> = primaryType extends 'EIP712Domain'
+  ? EIP712DomainDefinition<typedData, primaryType>
+  : MessageDefinition<typedData, primaryType>
 
-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
+type MessageDefinition<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData = keyof typedData,
+  ///
+  schema extends Record<string, unknown> = typedData extends TypedData
+    ? TypedDataToPrimitiveTypes<typedData>
+    : Record<string, unknown>,
+  message = schema[primaryType extends keyof schema
+    ? primaryType
+    : keyof schema],
+  primaryTypes = typedData extends TypedData ? keyof typedData : string,
+> = {
+  types: typedData
+} & {
+  primaryType:
+    | primaryTypes // show all values
+    | (primaryType extends primaryTypes ? primaryType : never) // infer value
+  domain?:
+    | (schema extends { EIP712Domain: infer domain }
+        ? domain
+        : Prettify<TypedDataDomain>)
+    | undefined
+  message: { [_: string]: any } extends message // Check if message was inferred
+    ? Record<string, unknown>
+    : message
+}
 
-export type GetTypedDataTypes<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-> = TPrimaryType extends 'EIP712Domain'
-  ? {
-      types?: Narrow<TTypedData>
-    }
-  : {
-      types: Narrow<TTypedData>
-    }
+type EIP712DomainDefinition<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends 'EIP712Domain' = 'EIP712Domain',
+  ///
+  schema extends Record<string, unknown> = typedData extends TypedData
+    ? TypedDataToPrimitiveTypes<typedData>
+    : Record<string, unknown>,
+> = {
+  types?: typedData | undefined
+} & {
+  primaryType: 'EIP712Domain' | primaryType
+  domain: schema extends { EIP712Domain: infer domain }
+    ? domain
+    : Prettify<TypedDataDomain>
+  message?: never
+}

package/src/utils/ens/errors.ts

@@ -0,0 +1,27 @@
+import { panicReasons } from '../../constants/solidity.js'
+import { BaseError } from '../../errors/base.js'
+import { ContractFunctionRevertedError } from '../../errors/contract.js'
+
+/*
+ * @description Checks if error is a valid null result UniversalResolver error
+ */
+export function isNullUniversalResolverError(
+  err: unknown,
+  callType: 'resolve' | 'reverse',
+): boolean {
+  if (!(err instanceof BaseError)) return false
+  const cause = err.walk((e) => e instanceof ContractFunctionRevertedError)
+  if (!(cause instanceof ContractFunctionRevertedError)) return false
+  if (cause.data?.errorName === 'ResolverNotFound') return true
+  if (cause.data?.errorName === 'ResolverWildcardNotSupported') return true
+  // Backwards compatibility for older UniversalResolver contracts
+  if (
+    cause.reason?.includes(
+      'Wildcard on non-extended resolvers is not supported',
+    )
+  )
+    return true
+  // No primary name set for address.
+  if (callType === 'reverse' && cause.reason === panicReasons[50]) return true
+  return false
+}

package/src/utils/signature/hashTypedData.ts

@@ -16,22 +16,23 @@ type MessageTypeProperty = {
 }
 
 export type HashTypedDataParameters<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-> = TypedDataDefinition<TTypedData, TPrimaryType>
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+> = TypedDataDefinition<typedData, primaryType>
 
 export type HashTypedDataReturnType = Hex
 
 export function hashTypedData<
-  TTypedData extends TypedData | { [key: string]: unknown },
-  TPrimaryType extends string = string,
->({
-  domain: domain_,
-  message,
-  primaryType,
-  types: types_,
-}: HashTypedDataParameters<TTypedData, TPrimaryType>): HashTypedDataReturnType {
-  const domain: TypedDataDomain = typeof domain_ === 'undefined' ? {} : domain_
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(
+  parameters: HashTypedDataParameters<typedData, primaryType>,
+): HashTypedDataReturnType {
+  const {
+    domain = {},
+    message,
+    primaryType,
+  } = parameters as unknown as HashTypedDataParameters
   const types = {
     EIP712Domain: [
       typeof domain?.name === 'string' && { name: 'name', type: 'string' },
@@ -46,7 +47,7 @@ export function hashTypedData<
       },
       domain?.salt && { name: 'salt', type: 'bytes32' },
     ].filter(Boolean),
-    ...(types_ as TTypedData),
+    ...parameters.types,
   }
 
   // Need to do a runtime validation check on addresses, byte ranges, integer ranges, etc
@@ -56,7 +57,7 @@ export function hashTypedData<
     message,
     primaryType,
     types,
-  } as TypedDataDefinition)
+  })
 
   const parts: Hex[] = ['0x1901']
   if (domain)
@@ -67,15 +68,14 @@ export function hashTypedData<
       }),
     )
 
-  if (primaryType !== 'EIP712Domain') {
+  if (primaryType !== 'EIP712Domain')
     parts.push(
       hashStruct({
         data: message,
-        primaryType: primaryType as string,
+        primaryType,
         types: types as Record<string, MessageTypeProperty[]>,
       }),
     )
-  }
 
   return keccak256(concat(parts))
 }

package/src/utils/signature/recoverTypedDataAddress.ts

@@ -7,33 +7,28 @@ import { hashTypedData } from './hashTypedData.js'
 import { recoverAddress } from './recoverAddress.js'
 
 export type RecoverTypedDataAddressParameters<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-> = TypedDataDefinition<TTypedData, TPrimaryType> & {
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+> = TypedDataDefinition<typedData, primaryType> & {
   signature: Hex | ByteArray
 }
 export type RecoverTypedDataAddressReturnType = Address
 
 export async function recoverTypedDataAddress<
-  TTypedData extends TypedData | { [key: string]: unknown },
-  TPrimaryType extends string = string,
->({
-  domain,
-  message,
-  primaryType,
-  signature,
-  types,
-}: RecoverTypedDataAddressParameters<
-  TTypedData,
-  TPrimaryType
->): Promise<RecoverTypedDataAddressReturnType> {
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(
+  parameters: RecoverTypedDataAddressParameters<typedData, primaryType>,
+): Promise<RecoverTypedDataAddressReturnType> {
+  const { domain, message, primaryType, signature, types } =
+    parameters as unknown as RecoverTypedDataAddressParameters
   return recoverAddress({
     hash: hashTypedData({
       domain,
       message,
       primaryType,
       types,
-    } as unknown as RecoverTypedDataAddressParameters),
+    }),
     signature,
   })
 }

package/src/utils/signature/verifyTypedData.ts

@@ -11,9 +11,9 @@ import {
 } from './recoverTypedDataAddress.js'
 
 export type VerifyTypedDataParameters<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-> = TypedDataDefinition<TTypedData, TPrimaryType> & {
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+> = TypedDataDefinition<typedData, primaryType> & {
   /** The address to verify the typed data for. */
   address: Address
   /** The signature to verify */
@@ -35,19 +35,13 @@ export type VerifyTypedDataReturnType = boolean
  * @returns Whether or not the signature is valid. {@link VerifyTypedDataReturnType}
  */
 export async function verifyTypedData<
-  TTypedData extends TypedData | { [key: string]: unknown },
-  TPrimaryType extends string = string,
->({
-  address,
-  domain,
-  message,
-  primaryType,
-  signature,
-  types,
-}: VerifyTypedDataParameters<
-  TTypedData,
-  TPrimaryType
->): Promise<VerifyTypedDataReturnType> {
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(
+  parameters: VerifyTypedDataParameters<typedData, primaryType>,
+): Promise<VerifyTypedDataReturnType> {
+  const { address, domain, message, primaryType, signature, types } =
+    parameters as unknown as VerifyTypedDataParameters
   return isAddressEqual(
     getAddress(address),
     await recoverTypedDataAddress({

package/src/utils/typedData.ts

@@ -1,4 +1,4 @@
-import type { TypedData, TypedDataParameter, TypedDataType } from 'abitype'
+import type { TypedData, TypedDataParameter } from 'abitype'
 
 import { BytesSizeMismatchError } from '../errors/abi.js'
 import { InvalidAddressError } from '../errors/address.js'
@@ -11,24 +11,19 @@ import { numberToHex } from './encoding/toHex.js'
 import { bytesRegex, integerRegex } from './regex.js'
 
 export function validateTypedData<
-  TTypedData extends TypedData | { [key: string]: unknown },
-  TPrimaryType extends string = string,
->({
-  domain,
-  message,
-  primaryType,
-  types: types_,
-}: TypedDataDefinition<TTypedData, TPrimaryType>) {
-  const types = types_ as TypedData
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(parameters: TypedDataDefinition<typedData, primaryType>) {
+  const { domain, message, primaryType, types } =
+    parameters as unknown as TypedDataDefinition
 
   const validateData = (
     struct: readonly TypedDataParameter[],
-    value_: Record<string, unknown>,
+    data: Record<string, unknown>,
   ) => {
     for (const param of struct) {
-      const { name, type: type_ } = param
-      const type = type_ as TypedDataType
-      const value = value_[name]
+      const { name, type } = param
+      const value = data[name]
 
       const integerMatch = type.match(integerRegex)
       if (
@@ -69,6 +64,6 @@ export function validateTypedData<
   if (primaryType !== 'EIP712Domain') {
     // Validate message types.
     const type = types[primaryType]
-    validateData(type, message as Record<string, unknown>)
+    validateData(type, message)
   }
 }