viem 0.0.0-tsc-and-nodenext-20230405154910 → 0.0.0-w-20230711200108

package/src/utils/abi/decodeAbiParameters.ts

@@ -1,24 +1,27 @@
 import type {
   AbiParameter,
-  AbiParametersToPrimitiveTypes,
   AbiParameterToPrimitiveType,
+  AbiParametersToPrimitiveTypes,
   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'
+} from '../../errors/abi.js'
+import type { Hex } from '../../types/misc.js'
+import { checksumAddress } from '../address/getAddress.js'
+import { size } from '../data/size.js'
+import { slice } from '../data/slice.js'
+import { trim } from '../data/trim.js'
 import {
   hexToBigInt,
   hexToBool,
   hexToNumber,
   hexToString,
-} from '../encoding/index.js'
+} from '../encoding/fromHex.js'
+
 import { getArrayComponents } from './encodeAbiParameters.js'
 
 export type DecodeAbiParametersReturnType<
@@ -34,8 +37,12 @@ export function decodeAbiParameters<
 >(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(size(data))
+  if (size(data) && size(data) < 32)
+    throw new AbiDecodingDataSizeTooSmallError({
+      data,
+      params: params as readonly AbiParameter[],
+      size: size(data),
+    })
   return decodeParams({
     data,
     params: params as readonly AbiParameter[],
@@ -54,6 +61,13 @@ function decodeParams<TParams extends readonly AbiParameter[]>({
   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)
@@ -91,7 +105,7 @@ function decodeParam({
     return decodeBytes(data, { param, position })
   }
 
-  const value = slice(data, position, position + 32) as Hex
+  const value = slice(data, position, position + 32, { strict: true }) as Hex
   if (param.type.startsWith('uint') || param.type.startsWith('int')) {
     return decodeNumber(value, { param })
   }
@@ -128,9 +142,13 @@ function decodeArray<TParam extends AbiParameter>(
   // 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))
+    const offset = hexToNumber(
+      slice(data, position, position + 32, { strict: true }),
+    )
     // Get the length of the array from the offset.
-    const length = hexToNumber(slice(data, offset, offset + 32))
+    const length = hexToNumber(
+      slice(data, offset, offset + 32, { strict: true }),
+    )
 
     let consumed = 0
     const value: AbiParameterToPrimitiveType<TParam>[] = []
@@ -158,7 +176,9 @@ function decodeArray<TParam extends AbiParameter>(
     let consumed = 0
     const value: AbiParameterToPrimitiveType<TParam>[] = []
     for (let i = 0; i < length; ++i) {
-      const offset = hexToNumber(slice(data, position, position + 32))
+      const offset = hexToNumber(
+        slice(data, position, position + 32, { strict: true }),
+      )
       const decodedChild = decodeParam({
         data: slice(data, offset),
         param,
@@ -199,15 +219,23 @@ function decodeBytes<TParam extends AbiParameter>(
   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))
+    const offset = hexToNumber(
+      slice(data, position, position + 32, { strict: true }),
+    )
+    const length = hexToNumber(
+      slice(data, offset, offset + 32, { strict: true }),
+    )
     // 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)
+    const value = slice(data, offset + 32, offset + 32 + length, {
+      strict: true,
+    })
     return { consumed: 32, value }
   }
 
-  const value = slice(data, position, position + parseInt(size))
+  const value = slice(data, position, position + parseInt(size), {
+    strict: true,
+  })
   return { consumed: 32, value }
 }
 
@@ -227,12 +255,14 @@ function decodeNumber<TParam extends AbiParameter>(
 }
 
 function decodeString(data: Hex, { position }: { position: number }) {
-  const offset = hexToNumber(slice(data, position, position + 32))
-  const length = hexToNumber(slice(data, offset, offset + 32))
+  const offset = hexToNumber(
+    slice(data, position, position + 32, { strict: true }),
+  )
+  const length = hexToNumber(slice(data, offset, offset + 32, { strict: true }))
   // 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)),
+    trim(slice(data, offset + 32, offset + 32 + length, { strict: true })),
   )
   return { consumed: 32, value }
 }
@@ -255,7 +285,9 @@ function decodeTuple<
   // 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))
+    const offset = hexToNumber(
+      slice(data, position, position + 32, { strict: true }),
+    )
     // Decode each component of the tuple, starting at the offset.
     for (let i = 0; i < param.components.length; ++i) {
       const component = param.components[i]

package/src/utils/abi/decodeDeployData.ts

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

package/src/utils/abi/decodeErrorResult.ts

@@ -1,31 +1,50 @@
-import type { Abi } from 'abitype'
-import { solidityError, solidityPanic } from '../../constants/index.js'
+import type {
+  Abi,
+  ExtractAbiError,
+  ExtractAbiErrorNames,
+  Narrow,
+} from 'abitype'
+
+import { solidityError, solidityPanic } from '../../constants/solidity.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'
+} from '../../errors/abi.js'
+import type { AbiItem, GetErrorArgs } from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import { slice } from '../data/slice.js'
+import { getFunctionSelector } from '../hash/getFunctionSelector.js'
+
 import { decodeAbiParameters } from './decodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
 
-export type DecodeErrorResultParameters = { abi?: Abi; data: Hex }
+export type DecodeErrorResultParameters<
+  TAbi extends Abi | readonly unknown[] = Abi,
+> = { abi?: Narrow<TAbi>; data: Hex }
 
-export type DecodeErrorResultReturnType = {
-  abiItem: AbiItem
-  errorName: string
-  args?: readonly unknown[]
-}
+export type DecodeErrorResultReturnType<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  _ErrorNames extends string = TAbi extends Abi
+    ? Abi extends TAbi
+      ? string
+      : ExtractAbiErrorNames<TAbi>
+    : string,
+> = {
+  [TName in _ErrorNames]: {
+    abiItem: TAbi extends Abi ? ExtractAbiError<TAbi, TName> : AbiItem
+    args: GetErrorArgs<TAbi, TName>['args']
+    errorName: TName
+  }
+}[_ErrorNames]
 
-export function decodeErrorResult({
+export function decodeErrorResult<TAbi extends Abi | readonly unknown[]>({
   abi,
   data,
-}: DecodeErrorResultParameters): DecodeErrorResultReturnType {
+}: DecodeErrorResultParameters<TAbi>): DecodeErrorResultReturnType<TAbi> {
   const signature = slice(data, 0, 4)
   if (signature === '0x') throw new AbiDecodingZeroDataError()
 
-  const abi_ = [...(abi || []), solidityError, solidityPanic]
+  const abi_ = [...((abi as Abi) || []), solidityError, solidityPanic]
   const abiItem = abi_.find(
     (x) =>
       x.type === 'error' && signature === getFunctionSelector(formatAbiItem(x)),
@@ -40,5 +59,5 @@ export function decodeErrorResult({
       ? decodeAbiParameters(abiItem.inputs, slice(data, 4))
       : undefined) as readonly unknown[] | undefined,
     errorName: (abiItem as { name: string }).name,
-  }
+  } as DecodeErrorResultReturnType<TAbi>
 }

package/src/utils/abi/decodeEventLog.ts

@@ -1,57 +1,84 @@
-import type { Abi, AbiParameter, Narrow } from 'abitype'
+import type { Abi, AbiParameter, ExtractAbiEventNames, Narrow } from 'abitype'
+
 import {
+  AbiDecodingDataSizeTooSmallError,
   AbiEventSignatureEmptyTopicsError,
   AbiEventSignatureNotFoundError,
+  DecodeLogDataMismatch,
   DecodeLogTopicsMismatch,
-} from '../../errors/index.js'
+} from '../../errors/abi.js'
 import type {
   EventDefinition,
   GetEventArgsFromTopics,
   InferEventName,
-  Hex,
-} from '../../types/index.js'
-import { getEventSelector } from '../hash/index.js'
+} from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import type { Prettify } from '../../types/utils.js'
+import { getEventSelector } from '../hash/getEventSelector.js'
+
 import { decodeAbiParameters } from './decodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
 
 export type DecodeEventLogParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TEventName extends string = string,
+  TEventName extends string | undefined = string,
   TTopics extends Hex[] = Hex[],
   TData extends Hex | undefined = undefined,
+  TStrict extends boolean = true,
 > = {
   abi: Narrow<TAbi>
   data?: TData
   eventName?: InferEventName<TAbi, TEventName>
+  strict?: TStrict
   topics: [signature: Hex, ...args: TTopics] | []
 }
 
 export type DecodeEventLogReturnType<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TEventName extends string = string,
+  TEventName extends string | undefined = string,
   TTopics extends Hex[] = Hex[],
   TData extends Hex | undefined = undefined,
-> = {
-  eventName: TEventName
-} & GetEventArgsFromTopics<TAbi, TEventName, TTopics, TData>
+  TStrict extends boolean = true,
+  _EventNames extends string = TAbi extends Abi
+    ? Abi extends TAbi
+      ? string
+      : ExtractAbiEventNames<TAbi>
+    : string,
+> = TEventName extends _EventNames[number]
+  ? Prettify<
+      {
+        eventName: TEventName
+      } & GetEventArgsFromTopics<TAbi, TEventName, TTopics, TData, TStrict>
+    >
+  : {
+      [TName in _EventNames]: Prettify<
+        {
+          eventName: TName
+        } & GetEventArgsFromTopics<TAbi, TName, TTopics, TData, TStrict>
+      >
+    }[_EventNames]
 
 const docsPath = '/docs/contract/decodeEventLog'
 
 export function decodeEventLog<
   TAbi extends Abi | readonly unknown[],
-  TEventName extends string,
-  TTopics extends Hex[],
+  TEventName extends string | undefined = undefined,
+  TTopics extends Hex[] = Hex[],
   TData extends Hex | undefined = undefined,
+  TStrict extends boolean = true,
 >({
   abi,
   data,
+  strict: strict_,
   topics,
 }: DecodeEventLogParameters<
   TAbi,
   TEventName,
   TTopics,
-  TData
->): DecodeEventLogReturnType<TAbi, TEventName, TTopics, TData> {
+  TData,
+  TStrict
+>): DecodeEventLogReturnType<TAbi, TEventName, TTopics, TData, TStrict> {
+  const strict = strict_ ?? true
   const [signature, ...argTopics] = topics
   if (!signature)
     throw new AbiEventSignatureEmptyTopicsError({
@@ -62,7 +89,7 @@ export function decodeEventLog<
       x.type === 'event' &&
       signature === getEventSelector(formatAbiItem(x) as EventDefinition),
   )
-  if (!(abiItem && 'name' in abiItem))
+  if (!(abiItem && 'name' in abiItem) || abiItem.type !== 'event')
     throw new AbiEventSignatureNotFoundError(signature, {
       docsPath,
     })
@@ -73,8 +100,8 @@ export function decodeEventLog<
   let args: any = isUnnamed ? [] : {}
 
   // Decode topics (indexed args).
+  const indexedInputs = inputs.filter((x) => 'indexed' in x && x.indexed)
   if (argTopics.length > 0) {
-    const indexedInputs = inputs.filter((x) => 'indexed' in x && x.indexed)
     for (let i = 0; i < indexedInputs.length; i++) {
       const param = indexedInputs[i]
       const topic = argTopics[i]
@@ -88,23 +115,51 @@ export function decodeEventLog<
   }
 
   // Decode data (non-indexed args).
-  if (data && data !== '0x') {
-    const params = inputs.filter((x) => !('indexed' in x && x.indexed))
-    const decodedData = decodeAbiParameters(params, data)
-    if (decodedData) {
-      if (isUnnamed) args = [...args, ...decodedData]
-      else {
-        for (let i = 0; i < params.length; i++) {
-          args[params[i].name!] = decodedData[i]
+  const nonIndexedInputs = inputs.filter((x) => !('indexed' in x && x.indexed))
+  if (nonIndexedInputs.length > 0) {
+    if (data && data !== '0x') {
+      try {
+        const decodedData = decodeAbiParameters(nonIndexedInputs, data)
+        if (decodedData) {
+          if (isUnnamed) args = [...args, ...decodedData]
+          else {
+            for (let i = 0; i < nonIndexedInputs.length; i++) {
+              args[nonIndexedInputs[i].name!] = decodedData[i]
+            }
+          }
+        }
+      } catch (err) {
+        if (strict) {
+          if (err instanceof AbiDecodingDataSizeTooSmallError)
+            throw new DecodeLogDataMismatch({
+              abiItem,
+              data: err.data,
+              params: err.params,
+              size: err.size,
+            })
+          throw err
         }
       }
+    } else if (strict) {
+      throw new DecodeLogDataMismatch({
+        abiItem,
+        data: '0x',
+        params: nonIndexedInputs,
+        size: 0,
+      })
     }
   }
 
   return {
     eventName: name,
     args: Object.values(args).length > 0 ? args : undefined,
-  } as unknown as DecodeEventLogReturnType<TAbi, TEventName, TTopics, TData>
+  } as unknown as DecodeEventLogReturnType<
+    TAbi,
+    TEventName,
+    TTopics,
+    TData,
+    TStrict
+  >
 }
 
 function decodeTopic({ param, value }: { param: AbiParameter; value: Hex }) {

package/src/utils/abi/decodeFunctionData.ts

@@ -1,9 +1,11 @@
 import type { Abi, ExtractAbiFunctionNames } from 'abitype'
 
-import { AbiFunctionSignatureNotFoundError } from '../../errors/index.js'
-import type { GetFunctionArgs, Hex } from '../../types/index.js'
-import { slice } from '../data/index.js'
-import { getFunctionSelector } from '../hash/index.js'
+import { AbiFunctionSignatureNotFoundError } from '../../errors/abi.js'
+import type { GetFunctionArgs } from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import { slice } from '../data/slice.js'
+import { getFunctionSelector } from '../hash/getFunctionSelector.js'
+
 import { decodeAbiParameters } from './decodeAbiParameters.js'
 import { formatAbiItem } from './formatAbiItem.js'
 

package/src/utils/abi/decodeFunctionResult.ts

@@ -1,37 +1,52 @@
-import type { Abi, Narrow } from 'abitype'
+import type { Abi, ExtractAbiFunctionNames, Narrow } from 'abitype'
+
 import {
   AbiFunctionNotFoundError,
   AbiFunctionOutputsNotFoundError,
-} from '../../errors/index.js'
+} from '../../errors/abi.js'
 import type {
+  AbiItem,
+  ContractFunctionResult,
   GetFunctionArgs,
   InferFunctionName,
-  ContractFunctionResult,
-  Hex,
-} from '../../types/index.js'
+} from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+
 import { decodeAbiParameters } from './decodeAbiParameters.js'
-import { getAbiItem } from './getAbiItem.js'
-import type { GetAbiItemParameters } from './getAbiItem.js'
+import { type GetAbiItemParameters, getAbiItem } from './getAbiItem.js'
 
 const docsPath = '/docs/contract/decodeFunctionResult'
 
 export type DecodeFunctionResultParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
+  TFunctionName extends string | undefined = string,
+  _FunctionName = InferFunctionName<TAbi, TFunctionName>,
 > = {
-  abi: Narrow<TAbi>
-  functionName: InferFunctionName<TAbi, TFunctionName>
+  functionName?: _FunctionName
   data: Hex
-} & Partial<GetFunctionArgs<TAbi, TFunctionName>>
+} & (TFunctionName extends string
+  ? { abi: Narrow<TAbi> } & Partial<GetFunctionArgs<TAbi, TFunctionName>>
+  : _FunctionName extends string
+  ? { abi: [Narrow<TAbi[number]>] } & Partial<
+      GetFunctionArgs<TAbi, _FunctionName>
+    >
+  : never)
 
 export type DecodeFunctionResultReturnType<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-> = ContractFunctionResult<TAbi, TFunctionName>
+  TFunctionName extends string | undefined = string,
+  _FunctionName extends string = TAbi extends Abi
+    ? Abi extends TAbi
+      ? string
+      : ExtractAbiFunctionNames<TAbi>[number]
+    : string,
+> = TFunctionName extends string
+  ? ContractFunctionResult<TAbi, TFunctionName>
+  : ContractFunctionResult<TAbi, _FunctionName>
 
 export function decodeFunctionResult<
   TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
+  TFunctionName extends string | undefined = undefined,
 >({
   abi,
   args,
@@ -41,17 +56,22 @@ export function decodeFunctionResult<
   TAbi,
   TFunctionName
 >): DecodeFunctionResultReturnType<TAbi, TFunctionName> {
-  const description = getAbiItem({
-    abi,
-    args,
-    name: functionName,
-  } as GetAbiItemParameters)
-  if (!description)
-    throw new AbiFunctionNotFoundError(functionName, { docsPath })
-  if (!('outputs' in description))
-    throw new AbiFunctionOutputsNotFoundError(functionName, { docsPath })
-
-  const values = decodeAbiParameters(description.outputs, data)
+  let abiItem = abi[0] as AbiItem
+  if (functionName) {
+    abiItem = getAbiItem({
+      abi,
+      args,
+      name: functionName,
+    } as GetAbiItemParameters)
+    if (!abiItem) throw new AbiFunctionNotFoundError(functionName, { docsPath })
+  }
+
+  if (abiItem.type !== 'function')
+    throw new AbiFunctionNotFoundError(undefined, { docsPath })
+  if (!abiItem.outputs)
+    throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath })
+
+  const values = decodeAbiParameters(abiItem.outputs, data)
   if (values && values.length > 1) return values as any
   if (values && values.length === 1) return values[0] as any
   return undefined as any

package/src/utils/abi/encodeAbiParameters.ts

@@ -1,7 +1,7 @@
 import type {
   AbiParameter,
-  AbiParametersToPrimitiveTypes,
   AbiParameterToPrimitiveType,
+  AbiParametersToPrimitiveTypes,
   Narrow,
 } from 'abitype'
 
@@ -10,13 +10,16 @@ import {
   AbiEncodingBytesSizeMismatchError,
   AbiEncodingLengthMismatchError,
   InvalidAbiEncodingTypeError,
-  InvalidAddressError,
   InvalidArrayError,
-} from '../../errors/index.js'
-import type { Hex } from '../../types/index.js'
-import { isAddress } from '../address/index.js'
-import { concat, padHex, size, slice } from '../data/index.js'
-import { boolToHex, numberToHex, stringToHex } from '../encoding/index.js'
+} from '../../errors/abi.js'
+import { InvalidAddressError } from '../../errors/address.js'
+import type { Hex } from '../../types/misc.js'
+import { isAddress } from '../address/isAddress.js'
+import { concat } from '../data/concat.js'
+import { padHex } from '../data/pad.js'
+import { size } from '../data/size.js'
+import { slice } from '../data/slice.js'
+import { boolToHex, numberToHex, stringToHex } from '../encoding/toHex.js'
 
 export type EncodeAbiParametersReturnType = Hex
 

package/src/utils/abi/encodeDeployData.ts

@@ -3,9 +3,11 @@ import type { Abi, Narrow } from 'abitype'
 import {
   AbiConstructorNotFoundError,
   AbiConstructorParamsNotFoundError,
-} from '../../errors/index.js'
-import type { GetConstructorArgs, Hex } from '../../types/index.js'
-import { concatHex } from '../data/index.js'
+} from '../../errors/abi.js'
+import type { GetConstructorArgs } from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import { concatHex } from '../data/concat.js'
+
 import { encodeAbiParameters } from './encodeAbiParameters.js'
 
 const docsPath = '/docs/contract/encodeDeployData'