viem 2.0.6 → 2.1.0

package/utils/abi/decodeAbiParameters.ts

@@ -1,341 +1,284 @@
-import type {
-  AbiParameter,
-  AbiParameterToPrimitiveType,
-  AbiParametersToPrimitiveTypes,
-} from 'abitype'
+import type { AbiParameter, AbiParametersToPrimitiveTypes } from 'abitype'
+
+import type { ByteArray, Hex } from '../../types/misc.js'
 
 import {
   AbiDecodingDataSizeTooSmallError,
-  type AbiDecodingDataSizeTooSmallErrorType,
-  AbiDecodingOffsetOutOfBoundsError,
   AbiDecodingZeroDataError,
-  type AbiDecodingZeroDataErrorType,
   InvalidAbiDecodingTypeError,
   type InvalidAbiDecodingTypeErrorType,
 } from '../../errors/abi.js'
-import type { Hex } from '../../types/misc.js'
+import type { ErrorType } from '../../errors/utils.js'
 import {
   type ChecksumAddressErrorType,
   checksumAddress,
 } from '../address/getAddress.js'
+import { type Cursor, createCursor } from '../cursor.js'
 import { type SizeErrorType, size } from '../data/size.js'
-import { type SliceErrorType, slice } from '../data/slice.js'
+import { type SliceBytesErrorType, sliceBytes } from '../data/slice.js'
 import { type TrimErrorType, trim } from '../data/trim.js'
 import {
-  type HexToBigIntErrorType,
-  type HexToBoolErrorType,
-  type HexToNumberErrorType,
-  type HexToStringErrorType,
-  hexToBigInt,
-  hexToBool,
-  hexToNumber,
-  hexToString,
-} from '../encoding/fromHex.js'
-
-import type { ErrorType } from '../../errors/utils.js'
-import {
-  type GetArrayComponentsErrorType,
-  getArrayComponents,
-} from './encodeAbiParameters.js'
+  type BytesToBigIntErrorType,
+  type BytesToBoolErrorType,
+  type BytesToNumberErrorType,
+  type BytesToStringErrorType,
+  bytesToBigInt,
+  bytesToBool,
+  bytesToNumber,
+  bytesToString,
+} from '../encoding/fromBytes.js'
+import { type HexToBytesErrorType, hexToBytes } from '../encoding/toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
+import { getArrayComponents } from './encodeAbiParameters.js'
 
 export type DecodeAbiParametersReturnType<
-  TParams extends
-    | readonly AbiParameter[]
-    | readonly unknown[] = readonly AbiParameter[],
+  TParams extends readonly AbiParameter[] = readonly AbiParameter[],
 > = AbiParametersToPrimitiveTypes<
   TParams extends readonly AbiParameter[] ? TParams : AbiParameter[]
 >
 
 export type DecodeAbiParametersErrorType =
-  | AbiDecodingDataSizeTooSmallErrorType
-  | AbiDecodingZeroDataErrorType
-  | DecodeParamsErrorType
+  | HexToBytesErrorType
+  | BytesToHexErrorType
+  | DecodeParameterErrorType
   | SizeErrorType
   | ErrorType
 
 export function decodeAbiParameters<
-  const TParams extends readonly AbiParameter[] | readonly unknown[],
->(params: TParams, data: Hex): DecodeAbiParametersReturnType<TParams> {
-  if (data === '0x' && (params as unknown[]).length > 0)
+  const TParams extends readonly AbiParameter[],
+>(
+  params: TParams,
+  data: ByteArray | Hex,
+): DecodeAbiParametersReturnType<TParams> {
+  const bytes = typeof data === 'string' ? hexToBytes(data) : data
+  const cursor = createCursor(bytes)
+
+  if (size(bytes) === 0 && params.length > 0)
     throw new AbiDecodingZeroDataError()
   if (size(data) && size(data) < 32)
     throw new AbiDecodingDataSizeTooSmallError({
-      data,
+      data: typeof data === 'string' ? data : bytesToHex(data),
       params: params as readonly AbiParameter[],
       size: size(data),
     })
-  return decodeParams({
-    data,
-    params: params as readonly AbiParameter[],
-  }) as unknown as DecodeAbiParametersReturnType<TParams>
-}
-
-////////////////////////////////////////////////////////////////////
-
-type TupleAbiParameter = AbiParameter & { components: readonly AbiParameter[] }
-
-type DecodeParamsErrorType = DecodeParamErrorType | SizeErrorType | ErrorType
-
-function decodeParams<const 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),
-      })
 
+  let consumed = 0
+  const values = []
+  for (let i = 0; i < params.length; ++i) {
     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
+    cursor.setPosition(consumed)
+    const [data, consumed_] = decodeParameter(cursor, param, {
+      staticPosition: 0,
+    })
+    consumed += consumed_
+    values.push(data)
   }
-
-  return decodedValues as unknown as AbiParametersToPrimitiveTypes<TParams>
+  return values as DecodeAbiParametersReturnType<TParams>
 }
 
-type DecodeParamErrorType =
+type DecodeParameterErrorType =
   | DecodeArrayErrorType
   | DecodeTupleErrorType
-  | DecodeStringErrorType
-  | DecodeBytesErrorType
-  | DecodeNumberErrorType
   | DecodeAddressErrorType
   | DecodeBoolErrorType
+  | DecodeBytesErrorType
+  | DecodeNumberErrorType
+  | DecodeStringErrorType
   | InvalidAbiDecodingTypeErrorType
-  | ErrorType
 
-function decodeParam({
-  data,
-  param,
-  position,
-}: { data: Hex; param: AbiParameter; position: number }): {
-  consumed: number
-  value: any
-} {
+function decodeParameter(
+  cursor: Cursor,
+  param: AbiParameter,
+  { staticPosition }: { staticPosition: number },
+) {
   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, { strict: true }) 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)
+    return decodeArray(cursor, { ...param, type }, { length, staticPosition })
   }
+  if (param.type === 'tuple')
+    return decodeTuple(cursor, param as TupleAbiParameter, { staticPosition })
+
+  if (param.type === 'address') return decodeAddress(cursor)
+  if (param.type === 'bool') return decodeBool(cursor)
+  if (param.type.startsWith('bytes'))
+    return decodeBytes(cursor, param, { staticPosition })
+  if (param.type.startsWith('uint') || param.type.startsWith('int'))
+    return decodeNumber(cursor, param)
+  if (param.type === 'string') return decodeString(cursor, { staticPosition })
   throw new InvalidAbiDecodingTypeError(param.type, {
     docsPath: '/docs/contract/decodeAbiParameters',
   })
 }
 
 ////////////////////////////////////////////////////////////////////
+// Type Decoders
+
+const sizeOfLength = 32
+const sizeOfOffset = 32
 
 type DecodeAddressErrorType =
   | ChecksumAddressErrorType
-  | SliceErrorType
+  | BytesToHexErrorType
+  | SliceBytesErrorType
   | ErrorType
 
-function decodeAddress(value: Hex) {
-  return { consumed: 32, value: checksumAddress(slice(value, -20)) }
+function decodeAddress(cursor: Cursor) {
+  const value = cursor.readBytes(32)
+  return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32]
 }
 
-type DecodeArrayErrorType = HexToNumberErrorType | SliceErrorType | ErrorType
-
-function decodeArray<const TParam extends AbiParameter>(
-  data: Hex,
-  {
-    param,
-    length,
-    position,
-  }: {
-    param: TParam
-    length: number | null
-    position: number
-  },
+type DecodeArrayErrorType = BytesToNumberErrorType | ErrorType
+
+function decodeArray(
+  cursor: Cursor,
+  param: AbiParameter,
+  { length, staticPosition }: { length: number | null; staticPosition: 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.
+  // this means we will need to wonder off to the pointer and decode.
   if (!length) {
-    // Get the offset of the array data.
-    const offset = hexToNumber(
-      slice(data, position, position + 32, { strict: true }),
-    )
-    if (offset < position)
-      throw new AbiDecodingOffsetOutOfBoundsError({ offset, position })
+    // Dealing with a dynamic type, so get the offset of the array data.
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset))
+
+    // Start is the static position of current slot + offset.
+    const start = staticPosition + offset
+    const startOfData = start + sizeOfLength
 
     // Get the length of the array from the offset.
-    const length = hexToNumber(
-      slice(data, offset, offset + 32, { strict: true }),
-    )
+    cursor.setPosition(start)
+    const length = bytesToNumber(cursor.readBytes(sizeOfLength))
+
+    // Check if the array has any dynamic children.
+    const dynamicChild = hasDynamicChild(param)
 
     let consumed = 0
-    const value: AbiParameterToPrimitiveType<TParam>[] = []
+    const value: unknown[] = []
     for (let i = 0; i < length; ++i) {
-      const decodedChild = decodeParam({
-        data: slice(data, offset + 32),
-        param,
-        position: consumed,
+      // If any of the children is dynamic, then all elements will be offset pointer, thus size of one slot (32 bytes).
+      // Otherwise, elements will be the size of their encoding (consumed bytes).
+      cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed))
+      const [data, consumed_] = decodeParameter(cursor, param, {
+        staticPosition: startOfData,
       })
-      consumed += decodedChild.consumed
-      value.push(decodedChild.value)
+      consumed += consumed_
+      value.push(data)
     }
-    return { value, consumed: 32 }
+
+    // As we have gone wondering, restore to the original position + next slot.
+    cursor.setPosition(staticPosition + 32)
+    return [value, 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]
+    // Dealing with dynamic types, so get the offset of the array data.
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset))
 
-    let consumed = 0
-    const value: AbiParameterToPrimitiveType<TParam>[] = []
+    // Start is the static position of current slot + offset.
+    const start = staticPosition + offset
+
+    const value: unknown[] = []
     for (let i = 0; i < length; ++i) {
-      const offset = hexToNumber(
-        slice(data, position, position + 32, { strict: true }),
-      )
-      const decodedChild = decodeParam({
-        data: slice(data, offset),
-        param,
-        position: dynamicChild ? consumed : i * 32,
+      // Move cursor along to the next slot (next offset pointer).
+      cursor.setPosition(start + i * 32)
+      const [data] = decodeParameter(cursor, param, {
+        staticPosition: start,
       })
-      consumed += decodedChild.consumed
-      value.push(decodedChild.value)
+      value.push(data)
     }
-    return { value, consumed: 32 }
+
+    // As we have gone wondering, restore to the original position + next slot.
+    cursor.setPosition(staticPosition + 32)
+    return [value, 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.
+  // If the length of the array is known in advance and the array is deeply static,
+  // then we can just decode each element in sequence.
   let consumed = 0
-  const value: AbiParameterToPrimitiveType<TParam>[] = []
+  const value: unknown[] = []
   for (let i = 0; i < length; ++i) {
-    const decodedChild = decodeParam({
-      data,
-      param,
-      position: position + consumed,
+    const [data, consumed_] = decodeParameter(cursor, param, {
+      staticPosition: staticPosition + consumed,
     })
-    consumed += decodedChild.consumed
-    value.push(decodedChild.value)
+    consumed += consumed_
+    value.push(data)
   }
-  return { value, consumed }
+  return [value, consumed]
 }
 
-type DecodeBoolErrorType = HexToBoolErrorType | ErrorType
+type DecodeBoolErrorType = BytesToBoolErrorType | ErrorType
 
-function decodeBool(value: Hex) {
-  return { consumed: 32, value: hexToBool(value) }
+function decodeBool(cursor: Cursor) {
+  return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32]
 }
 
-type DecodeBytesErrorType = HexToNumberErrorType | SliceErrorType | ErrorType
+type DecodeBytesErrorType =
+  | BytesToNumberErrorType
+  | BytesToHexErrorType
+  | ErrorType
 
-function decodeBytes<const TParam extends AbiParameter>(
-  data: Hex,
-  { param, position }: { param: TParam; position: number },
+function decodeBytes(
+  cursor: Cursor,
+  param: AbiParameter,
+  { staticPosition }: { staticPosition: 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, { strict: true }),
-    )
-    const length = hexToNumber(
-      slice(data, offset, offset + 32, { strict: true }),
-    )
+    // Dealing with dynamic types, so get the offset of the bytes data.
+    const offset = bytesToNumber(cursor.readBytes(32))
+
+    // Set position of the cursor to start of bytes data.
+    cursor.setPosition(staticPosition + offset)
+
+    const length = bytesToNumber(cursor.readBytes(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, {
-      strict: true,
-    })
-    return { consumed: 32, value }
+    if (length === 0) {
+      // As we have gone wondering, restore to the original position + next slot.
+      cursor.setPosition(staticPosition + 32)
+      return ['0x', 32]
+    }
+
+    const data = cursor.readBytes(length)
+
+    // As we have gone wondering, restore to the original position + next slot.
+    cursor.setPosition(staticPosition + 32)
+    return [bytesToHex(data), 32]
   }
 
-  const value = slice(data, position, position + parseInt(size), {
-    strict: true,
-  })
-  return { consumed: 32, value }
+  const value = bytesToHex(cursor.readBytes(parseInt(size), 32))
+  return [value, 32]
 }
 
 type DecodeNumberErrorType =
-  | HexToBigIntErrorType
-  | HexToNumberErrorType
+  | BytesToNumberErrorType
+  | BytesToBigIntErrorType
   | ErrorType
 
-function decodeNumber<const TParam extends AbiParameter>(
-  value: Hex,
-  { param }: { param: TParam },
-) {
+function decodeNumber(cursor: Cursor, param: AbiParameter) {
   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 }),
-  }
+  const value = cursor.readBytes(32)
+  return [
+    size > 48
+      ? bytesToBigInt(value, { signed })
+      : bytesToNumber(value, { signed }),
+    32,
+  ]
 }
 
-type DecodeStringErrorType =
-  | HexToNumberErrorType
-  | HexToStringErrorType
-  | SliceErrorType
-  | TrimErrorType
-  | ErrorType
+type TupleAbiParameter = AbiParameter & { components: readonly AbiParameter[] }
 
-function decodeString(data: Hex, { position }: { position: number }) {
-  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, { strict: true })),
-  )
-  return { consumed: 32, value }
-}
+type DecodeTupleErrorType = BytesToNumberErrorType | ErrorType
 
-type DecodeTupleErrorType =
-  | HasDynamicChildErrorType
-  | HexToNumberErrorType
-  | SliceErrorType
-  | ErrorType
-
-function decodeTuple<
-  const TParam extends AbiParameter & { components: readonly AbiParameter[] },
->(data: Hex, { param, position }: { param: TParam; position: number }) {
+function decodeTuple(
+  cursor: Cursor,
+  param: TupleAbiParameter,
+  { staticPosition }: { staticPosition: 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
@@ -351,39 +294,73 @@ 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, { strict: true }),
-    )
-    // Decode each component of the tuple, starting at the offset.
+    // Dealing with dynamic types, so get the offset of the tuple data.
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset))
+
+    // Start is the static position of referencing slot + offset.
+    const start = staticPosition + 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,
+      cursor.setPosition(start + consumed)
+      const [data, consumed_] = decodeParameter(cursor, component, {
+        staticPosition: start,
       })
-      consumed += decodedChild.consumed
-      value[hasUnnamedChild ? i : component?.name!] = decodedChild.value
+      consumed += consumed_
+      value[hasUnnamedChild ? i : component?.name!] = data
     }
-    return { consumed: 32, value }
+
+    // As we have gone wondering, restore to the original position + next slot.
+    cursor.setPosition(staticPosition + 32)
+    return [value, 32]
   }
 
   // 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,
+    const [data, consumed_] = decodeParameter(cursor, component, {
+      staticPosition,
     })
-    consumed += decodedChild.consumed
-    value[hasUnnamedChild ? i : component?.name!] = decodedChild.value
+    value[hasUnnamedChild ? i : component?.name!] = data
+    consumed += consumed_
   }
-  return { consumed, value }
+  return [value, consumed]
 }
 
-type HasDynamicChildErrorType = GetArrayComponentsErrorType | ErrorType
+type DecodeStringErrorType =
+  | BytesToNumberErrorType
+  | BytesToStringErrorType
+  | TrimErrorType
+  | ErrorType
+
+function decodeString(
+  cursor: Cursor,
+  { staticPosition }: { staticPosition: number },
+) {
+  // Get offset to start of string data.
+  const offset = bytesToNumber(cursor.readBytes(32))
+
+  // Start is the static position of current slot + offset.
+  const start = staticPosition + offset
+  cursor.setPosition(start)
+
+  const length = bytesToNumber(cursor.readBytes(32))
+
+  // If there is no length, we have zero data (empty string).
+  if (length === 0) {
+    cursor.setPosition(staticPosition + 32)
+    return ['', 32]
+  }
+
+  const data = cursor.readBytes(length, 32)
+  const value = bytesToString(trim(data))
+
+  // As we have gone wondering, restore to the original position + next slot.
+  cursor.setPosition(staticPosition + 32)
+
+  return [value, 32]
+}
 
 function hasDynamicChild(param: AbiParameter) {
   const { type } = param

package/utils/abi/decodeEventLog.ts

@@ -24,11 +24,13 @@ import type {
   Prettify,
   UnionEvaluate,
 } from '../../types/utils.js'
+import { size } from '../data/size.js'
 import {
   type GetEventSelectorErrorType,
   getEventSelector,
 } from '../hash/getEventSelector.js'
 
+import { PositionOutOfBoundsError } from '../../errors/cursor.js'
 import {
   type DecodeAbiParametersErrorType,
   decodeAbiParameters,
@@ -156,12 +158,15 @@ export function decodeEventLog<
         }
       } catch (err) {
         if (strict) {
-          if (err instanceof AbiDecodingDataSizeTooSmallError)
+          if (
+            err instanceof AbiDecodingDataSizeTooSmallError ||
+            err instanceof PositionOutOfBoundsError
+          )
             throw new DecodeLogDataMismatch({
               abiItem,
-              data: err.data,
-              params: err.params,
-              size: err.size,
+              data: data,
+              params: nonIndexedInputs,
+              size: size(data),
             })
           throw err
         }