viem 0.0.1-alpha.24 → 0.0.1-alpha.26

package/src/utils/abi/decodeAbi.ts

@@ -1,300 +0,0 @@
-import {
-  AbiParameter,
-  AbiParametersToPrimitiveTypes,
-  AbiParameterToPrimitiveType,
-  Narrow,
-} from 'abitype'
-
-import {
-  AbiDecodingDataSizeInvalidError,
-  AbiDecodingZeroDataError,
-  InvalidAbiDecodingTypeError,
-} from '../../errors'
-import { Hex } from '../../types'
-import { checksumAddress } from '../address'
-import { size, slice, trim } from '../data'
-import { hexToBigInt, hexToBool, hexToNumber, hexToString } from '../encoding'
-import { getArrayComponents } from './encodeAbi'
-
-export type DecodeAbiArgs<
-  TParams extends
-    | readonly AbiParameter[]
-    | readonly unknown[] = readonly AbiParameter[],
-> = {
-  data: Hex
-  params: Narrow<TParams>
-}
-
-export function decodeAbi<
-  TParams extends readonly AbiParameter[] | readonly unknown[],
->({ data, params }: DecodeAbiArgs<TParams>) {
-  if (data === '0x' && params.length > 0) throw new AbiDecodingZeroDataError()
-  if (size(data) % 32 !== 0)
-    throw new AbiDecodingDataSizeInvalidError(size(data))
-  const values = decodeParams({
-    data,
-    params: params as readonly AbiParameter[],
-  })
-  if (values.length === 0) return undefined
-  return values
-}
-
-////////////////////////////////////////////////////////////////////
-
-type TupleAbiParameter = AbiParameter & { components: readonly AbiParameter[] }
-
-function decodeParams<TParams extends readonly AbiParameter[]>({
-  data,
-  params,
-}: {
-  data: Hex
-  params: TParams
-}) {
-  let decodedValues: unknown[] = []
-  let position = 0
-
-  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
-  }
-
-  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 })
-  }
-
-  let 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/decodeAbi',
-  })
-}
-
-////////////////////////////////////////////////////////////////////
-
-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
-    let 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
-    let 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 }
-  }
-
-  // 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
-  let 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))
-    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))
-  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.
-  let 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.test.ts

@@ -1,151 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { decodeDeployData } from './decodeDeployData'
-
-test('constructor()', () => {
-  expect(
-    decodeDeployData({
-      abi: [
-        {
-          inputs: [],
-          stateMutability: 'nonpayable',
-          type: 'constructor',
-        },
-      ],
-      bytecode:
-        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
-      data: '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
-    }),
-  ).toEqual({
-    bytecode:
-      '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
-  })
-  expect(
-    decodeDeployData({
-      abi: [
-        {
-          stateMutability: 'nonpayable',
-          type: 'constructor',
-        },
-      ],
-      bytecode:
-        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
-      data: '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
-    }),
-  ).toEqual({
-    bytecode:
-      '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
-  })
-})
-
-test('constructor(uint256)', () => {
-  expect(
-    decodeDeployData({
-      abi: [
-        {
-          inputs: [
-            {
-              internalType: 'uint256',
-              name: 'a',
-              type: 'uint256',
-            },
-          ],
-          stateMutability: 'nonpayable',
-          type: 'constructor',
-        },
-      ],
-      bytecode:
-        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
-      data: '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c634300080700330000000000000000000000000000000000000000000000000000000000010f2c',
-    }),
-  ).toEqual({
-    args: [69420n],
-    bytecode:
-      '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
-  })
-})
-
-test('error: constructor not found', () => {
-  expect(() =>
-    decodeDeployData({
-      abi: [{}],
-      bytecode:
-        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
-      data: '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c634300080700330000000000000000000000000000000000000000000000000000000000010f2c',
-    }),
-  ).toThrowErrorMatchingInlineSnapshot(`
-    "A constructor was not found on the ABI.
-    Make sure you are using the correct ABI and that the constructor exists on it.
-
-    Docs: https://viem.sh/docs/contract/decodeDeployData
-    Version: viem@1.0.2"
-  `)
-})
-
-test('error: no inputs', () => {
-  expect(() =>
-    decodeDeployData({
-      abi: [
-        {
-          stateMutability: 'nonpayable',
-          type: 'constructor',
-        },
-      ],
-      bytecode:
-        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
-      data: '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c634300080700330000000000000000000000000000000000000000000000000000000000010f2c',
-    }),
-  ).toThrowErrorMatchingInlineSnapshot(
-    `
-    "Constructor arguments were provided (\`args\`), but a constructor parameters (\`inputs\`) were not found on the ABI.
-    Make sure you are using the correct ABI, and that the \`inputs\` attribute on the constructor exists.
-
-    Docs: https://viem.sh/docs/contract/decodeDeployData
-    Version: viem@1.0.2"
-  `,
-  )
-  expect(() =>
-    decodeDeployData({
-      abi: [
-        {
-          inputs: [],
-          stateMutability: 'nonpayable',
-          type: 'constructor',
-        },
-      ],
-      bytecode:
-        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
-      data: '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c634300080700330000000000000000000000000000000000000000000000000000000000010f2c',
-    }),
-  ).toThrowErrorMatchingInlineSnapshot(
-    `
-    "Constructor arguments were provided (\`args\`), but a constructor parameters (\`inputs\`) were not found on the ABI.
-    Make sure you are using the correct ABI, and that the \`inputs\` attribute on the constructor exists.
-
-    Docs: https://viem.sh/docs/contract/decodeDeployData
-    Version: viem@1.0.2"
-  `,
-  )
-  expect(() =>
-    decodeDeployData({
-      abi: [
-        {
-          inputs: undefined,
-          stateMutability: 'nonpayable',
-          type: 'constructor',
-        },
-      ],
-      bytecode:
-        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
-      data: '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c634300080700330000000000000000000000000000000000000000000000000000000000010f2c',
-    }),
-  ).toThrowErrorMatchingInlineSnapshot(
-    `
-    "Constructor arguments were provided (\`args\`), but a constructor parameters (\`inputs\`) were not found on the ABI.
-    Make sure you are using the correct ABI, and that the \`inputs\` attribute on the constructor exists.
-
-    Docs: https://viem.sh/docs/contract/decodeDeployData
-    Version: viem@1.0.2"
-  `,
-  )
-})

package/src/utils/abi/decodeDeployData.ts

@@ -1,44 +0,0 @@
-import { Abi } from 'abitype'
-
-import {
-  AbiConstructorNotFoundError,
-  AbiConstructorParamsNotFoundError,
-} from '../../errors'
-import { Hex } from '../../types'
-import { decodeAbi } from './decodeAbi'
-
-const docsPath = '/docs/contract/decodeDeployData'
-
-export type DecodeDeployDataArgs<TAbi extends Abi | readonly unknown[] = Abi> =
-  {
-    abi: TAbi
-    bytecode: Hex
-    data: Hex
-  }
-export type DecodeDeployDataResponse = {
-  args?: readonly unknown[] | undefined
-  bytecode: Hex
-}
-
-export function decodeDeployData<TAbi extends Abi | readonly unknown[]>({
-  abi,
-  bytecode,
-  data,
-}: DecodeDeployDataArgs<TAbi>): DecodeDeployDataResponse {
-  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 = decodeAbi({
-    data: `0x${data.replace(bytecode, '')}`,
-    params: description.inputs,
-  })
-  return { args, bytecode }
-}