viem 0.0.1-alpha.14 → 0.0.1-alpha.16

package/src/utils/abi/decodeAbi.ts

@@ -0,0 +1,296 @@
+import {
+  AbiParameter,
+  AbiParametersToPrimitiveTypes,
+  AbiParameterToPrimitiveType,
+} 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[]> = {
+  data: Hex
+  params: TParams
+}
+
+export function decodeAbi<TParams extends readonly AbiParameter[]>({
+  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,
+  })
+  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,159 @@
+import { expect, test } from 'vitest'
+
+import { decodeDeployData } from './decodeDeployData'
+
+test('constructor()', () => {
+  expect(
+    decodeDeployData({
+      abi: [
+        {
+          inputs: [],
+          stateMutability: 'nonpayable',
+          type: 'constructor',
+        },
+      ] as const,
+      bytecode:
+        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+      data: '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+    }),
+  ).toEqual({
+    bytecode:
+      '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+  })
+  expect(
+    decodeDeployData({
+      // @ts-expect-error
+      abi: [
+        {
+          stateMutability: 'nonpayable',
+          type: 'constructor',
+        },
+      ] as const,
+      bytecode:
+        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+      data: '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+    }),
+  ).toEqual({
+    bytecode:
+      '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+  })
+})
+
+test('constructor(uint256)', () => {
+  expect(
+    decodeDeployData({
+      abi: [
+        {
+          inputs: [
+            {
+              internalType: 'uint256',
+              name: 'a',
+              type: 'uint256',
+            },
+          ],
+          stateMutability: 'nonpayable',
+          type: 'constructor',
+        },
+      ] as const,
+      bytecode:
+        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+      data: '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c634300080700330000000000000000000000000000000000000000000000000000000000010f2c',
+    }),
+  ).toEqual({
+    args: [69420n],
+    bytecode:
+      '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+  })
+})
+
+test('error: constructor not found', () => {
+  expect(() =>
+    decodeDeployData({
+      // @ts-expect-error
+      abi: [{}] as const,
+      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({
+      // @ts-expect-error
+      abi: [
+        {
+          stateMutability: 'nonpayable',
+          type: 'constructor',
+        },
+      ] as const,
+      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',
+        },
+      ] as const,
+      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({
+      // @ts-expect-error
+      abi: [
+        {
+          inputs: undefined,
+          stateMutability: 'nonpayable',
+          type: 'constructor',
+        },
+      ] as const,
+      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,41 @@
+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 = Abi> = {
+  abi: TAbi
+  bytecode: Hex
+  data: Hex
+}
+export type DecodeDeployDataResponse = {
+  args?: readonly unknown[] | undefined
+  bytecode: Hex
+}
+
+export function decodeDeployData<TAbi extends Abi = Abi>({
+  abi,
+  bytecode,
+  data,
+}: DecodeDeployDataArgs<TAbi>): DecodeDeployDataResponse {
+  if (data === bytecode) return { bytecode }
+
+  const description = 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 }
+}

package/src/utils/abi/decodeErrorResult.test.ts

@@ -0,0 +1,130 @@
+import { expect, test } from 'vitest'
+
+import { decodeErrorResult } from './decodeErrorResult'
+
+test('revert SoldOutError()', () => {
+  expect(
+    decodeErrorResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'SoldOutError',
+          type: 'error',
+        },
+      ],
+      data: '0x7f6df6bb',
+    }),
+  ).toEqual({ errorName: 'SoldOutError', args: undefined })
+  expect(
+    decodeErrorResult({
+      abi: [
+        // @ts-expect-error
+        {
+          name: 'SoldOutError',
+          type: 'error',
+        },
+      ],
+      data: '0x7f6df6bb',
+    }),
+  ).toEqual({ errorName: 'SoldOutError', args: undefined })
+})
+
+test('revert AccessDeniedError(string)', () => {
+  expect(
+    decodeErrorResult({
+      abi: [
+        {
+          inputs: [
+            {
+              internalType: 'string',
+              name: 'a',
+              type: 'string',
+            },
+          ],
+          name: 'AccessDeniedError',
+          type: 'error',
+        },
+      ],
+      data: '0x83aa206e0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001a796f7520646f206e6f7420686176652061636365737320736572000000000000',
+    }),
+  ).toEqual({
+    errorName: 'AccessDeniedError',
+    args: ['you do not have access ser'],
+  })
+})
+
+test('revert AccessDeniedError((uint256,bool,address,uint256))', () => {
+  expect(
+    decodeErrorResult({
+      abi: [
+        {
+          inputs: [
+            {
+              components: [
+                {
+                  internalType: 'uint256',
+                  name: 'weight',
+                  type: 'uint256',
+                },
+                {
+                  internalType: 'bool',
+                  name: 'voted',
+                  type: 'bool',
+                },
+                {
+                  internalType: 'address',
+                  name: 'delegate',
+                  type: 'address',
+                },
+                {
+                  internalType: 'uint256',
+                  name: 'vote',
+                  type: 'uint256',
+                },
+              ],
+              internalType: 'struct Ballot.Voter',
+              name: 'voter',
+              type: 'tuple',
+            },
+          ],
+          name: 'AccessDeniedError',
+          type: 'error',
+        },
+      ],
+      data: '0x0a1895610000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000029',
+    }),
+  ).toEqual({
+    errorName: 'AccessDeniedError',
+    args: [
+      {
+        delegate: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+        vote: 41n,
+        voted: true,
+        weight: 69420n,
+      },
+    ],
+  })
+})
+
+test("errors: error doesn't exist", () => {
+  expect(() =>
+    decodeErrorResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'SoldOutError',
+          type: 'error',
+        },
+      ],
+      data: '0xa37414670000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000029',
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "Encoded error signature \\"0xa3741467\\" not found on ABI.
+    Make sure you are using the correct ABI and that the error exists on it.
+    You can look up the signature \\"0xa3741467\\" here: https://sig.eth.samczsun.com/.
+
+    Docs: https://viem.sh/docs/contract/decodeErrorResult
+
+    Version: viem@1.0.2"
+  `)
+})

package/src/utils/abi/decodeErrorResult.ts

@@ -0,0 +1,28 @@
+import { Abi } from 'abitype'
+import { AbiErrorSignatureNotFoundError } from '../../errors'
+import { Hex } from '../../types'
+import { slice } from '../data'
+import { getFunctionSignature } from '../hash'
+import { decodeAbi } from './decodeAbi'
+import { formatAbiItemWithParams } from './formatAbiItemWithParams'
+
+export type DecodeErrorResultArgs = { abi: Abi; data: Hex }
+
+export function decodeErrorResult({ abi, data }: DecodeErrorResultArgs) {
+  const signature = slice(data, 0, 4)
+  const description = abi.find(
+    (x) => signature === getFunctionSignature(formatAbiItemWithParams(x)),
+  )
+  if (!description)
+    throw new AbiErrorSignatureNotFoundError(signature, {
+      docsPath: '/docs/contract/decodeErrorResult',
+    })
+  return {
+    errorName: (description as { name: string }).name,
+    args: ('inputs' in description &&
+    description.inputs &&
+    description.inputs.length > 0
+      ? decodeAbi({ data: slice(data, 4), params: description.inputs })
+      : undefined) as readonly unknown[] | undefined,
+  }
+}