viem 0.0.1-cjs.10 → 0.0.1-sushi.26

package/src/utils/abi/decodeAbi.ts

@@ -0,0 +1,300 @@
+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

@@ -0,0 +1,151 @@
+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

@@ -0,0 +1,44 @@
+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 }
+}