viem 0.0.1-alpha.2 → 0.0.1-alpha.21

package/src/utils/abi/encodeAbi.ts

@@ -0,0 +1,264 @@
+import {
+  AbiParameter,
+  AbiParametersToPrimitiveTypes,
+  AbiParameterToPrimitiveType,
+} from 'abitype'
+
+import {
+  AbiEncodingArrayLengthMismatchError,
+  AbiEncodingLengthMismatchError,
+  InvalidAbiEncodingTypeError,
+  InvalidArrayError,
+} from '../../errors'
+import { Hex } from '../../types'
+import { concat, padHex, size, slice } from '../data'
+import { boolToHex, numberToHex, stringToHex } from '../encoding'
+
+export type EncodeAbiArgs<TParams extends readonly AbiParameter[]> = {
+  params: TParams
+  values: AbiParametersToPrimitiveTypes<TParams>
+}
+
+/**
+ * @description Encodes a list of primitive values into an ABI-encoded hex value.
+ */
+export function encodeAbi<TParams extends readonly AbiParameter[]>({
+  params,
+  values,
+}: EncodeAbiArgs<TParams>) {
+  if (params.length !== values.length)
+    throw new AbiEncodingLengthMismatchError({
+      expectedLength: params.length,
+      givenLength: values.length,
+    })
+  // Prepare the parameters to determine dynamic types to encode.
+  const preparedParams = prepareParams({ params, values })
+  const data = encodeParams(preparedParams)
+  if (data.length === 0) return '0x'
+  return data
+}
+
+/////////////////////////////////////////////////////////////////
+
+type PreparedParam = { dynamic: boolean; encoded: Hex }
+
+type TupleAbiParameter = AbiParameter & { components: readonly AbiParameter[] }
+type Tuple = AbiParameterToPrimitiveType<TupleAbiParameter>
+
+function prepareParams<TParams extends readonly AbiParameter[]>({
+  params,
+  values,
+}: {
+  params: TParams
+  values: AbiParametersToPrimitiveTypes<TParams>
+}) {
+  let preparedParams: PreparedParam[] = []
+  for (let i = 0; i < params.length; i++) {
+    preparedParams.push(prepareParam({ param: params[i], value: values[i] }))
+  }
+  return preparedParams
+}
+
+function prepareParam<TParam extends AbiParameter>({
+  param,
+  value,
+}: {
+  param: TParam
+  value: AbiParameterToPrimitiveType<TParam>
+}): PreparedParam {
+  const arrayComponents = getArrayComponents(param.type)
+  if (arrayComponents) {
+    const [length, type] = arrayComponents
+    return encodeArray(value, { length, param: { ...param, type } })
+  }
+  if (param.type === 'tuple') {
+    return encodeTuple(value as unknown as Tuple, {
+      param: param as TupleAbiParameter,
+    })
+  }
+  if (param.type === 'address') {
+    return encodeAddress(value as unknown as Hex)
+  }
+  if (param.type === 'bool') {
+    return encodeBool(value as unknown as boolean)
+  }
+  if (param.type.startsWith('uint') || param.type.startsWith('int')) {
+    const signed = param.type.startsWith('int')
+    return encodeNumber(value as unknown as number, { signed })
+  }
+  if (param.type.startsWith('bytes')) {
+    return encodeBytes(value as unknown as Hex, { param })
+  }
+  if (param.type === 'string') {
+    return encodeString(value as unknown as string)
+  }
+  throw new InvalidAbiEncodingTypeError(param.type, {
+    docsPath: '/docs/contract/encodeAbi',
+  })
+}
+
+/////////////////////////////////////////////////////////////////
+
+function encodeParams(preparedParams: PreparedParam[]): Hex {
+  // 1. Compute the size of the static part of the parameters.
+  let staticSize = 0
+  for (let i = 0; i < preparedParams.length; i++) {
+    const { dynamic, encoded } = preparedParams[i]
+    if (dynamic) staticSize += 32
+    else staticSize += size(encoded)
+  }
+
+  // 2. Split the parameters into static and dynamic parts.
+  let staticParams: Hex[] = []
+  let dynamicParams: Hex[] = []
+  let dynamicSize = 0
+  for (let i = 0; i < preparedParams.length; i++) {
+    const { dynamic, encoded } = preparedParams[i]
+    if (dynamic) {
+      staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }))
+      dynamicParams.push(encoded)
+      dynamicSize += size(encoded)
+    } else {
+      staticParams.push(encoded)
+    }
+  }
+
+  // 3. Concatenate static and dynamic parts.
+  return concat([...staticParams, ...dynamicParams])
+}
+
+/////////////////////////////////////////////////////////////////
+
+function encodeAddress(value: Hex): PreparedParam {
+  return { dynamic: false, encoded: padHex(value.toLowerCase() as Hex) }
+}
+
+function encodeArray<TParam extends AbiParameter>(
+  value: AbiParameterToPrimitiveType<TParam>,
+  {
+    length,
+    param,
+  }: {
+    length: number | null
+    param: TParam
+  },
+): PreparedParam {
+  let dynamic = length === null
+
+  if (!Array.isArray(value)) throw new InvalidArrayError(value)
+  if (!dynamic && value.length !== length)
+    throw new AbiEncodingArrayLengthMismatchError({
+      expectedLength: length!,
+      givenLength: value.length,
+      type: `${param.type}[${length}]`,
+    })
+
+  let dynamicChild = false
+  let preparedParams: PreparedParam[] = []
+  for (let i = 0; i < value.length; i++) {
+    const preparedParam = prepareParam({ param, value: value[i] })
+    if (preparedParam.dynamic) dynamicChild = true
+    preparedParams.push(preparedParam)
+  }
+
+  if (dynamic || dynamicChild) {
+    const data = encodeParams(preparedParams)
+    if (dynamic) {
+      const length = numberToHex(preparedParams.length, { size: 32 })
+      return {
+        dynamic: true,
+        encoded: preparedParams.length > 0 ? concat([length, data]) : length,
+      }
+    }
+    if (dynamicChild) return { dynamic: true, encoded: data }
+  }
+  return {
+    dynamic: false,
+    encoded: concat(preparedParams.map(({ encoded }) => encoded)),
+  }
+}
+
+function encodeBytes<TParam extends AbiParameter>(
+  value: Hex,
+  { param }: { param: TParam },
+): PreparedParam {
+  const [_, size_] = param.type.split('bytes')
+  if (!size_) {
+    const partsLength = Math.floor(size(value) / 32)
+    const parts: Hex[] = []
+    for (let i = 0; i < partsLength + 1; i++) {
+      parts.push(padHex(slice(value, i * 32, (i + 1) * 32), { dir: 'right' }))
+    }
+    return {
+      dynamic: true,
+      encoded: concat([
+        padHex(numberToHex(size(value), { size: 32 })),
+        ...parts,
+      ]),
+    }
+  }
+  return { dynamic: false, encoded: padHex(value, { dir: 'right' }) }
+}
+
+function encodeBool(value: boolean): PreparedParam {
+  return { dynamic: false, encoded: padHex(boolToHex(value)) }
+}
+
+function encodeNumber(
+  value: number,
+  { signed }: { signed: boolean },
+): PreparedParam {
+  return {
+    dynamic: false,
+    encoded: numberToHex(value, {
+      size: 32,
+      signed,
+    }),
+  }
+}
+
+function encodeString(value: string): PreparedParam {
+  return {
+    dynamic: true,
+    encoded: concat([
+      padHex(numberToHex(value.length, { size: 32 })),
+      padHex(stringToHex(value), { dir: 'right' }),
+    ]),
+  }
+}
+
+function encodeTuple<
+  TParam extends AbiParameter & { components: readonly AbiParameter[] },
+>(
+  value: AbiParameterToPrimitiveType<TParam>,
+  { param }: { param: TParam },
+): PreparedParam {
+  let dynamic = false
+  let preparedParams: PreparedParam[] = []
+  for (let i = 0; i < param.components.length; i++) {
+    const param_ = param.components[i]
+    const index = Array.isArray(value) ? i : param_.name
+    const preparedParam = prepareParam({
+      param: param_,
+      value: (value as any)[index!] as any,
+    })
+    preparedParams.push(preparedParam)
+    dynamic = preparedParam.dynamic
+  }
+  return {
+    dynamic,
+    encoded: dynamic
+      ? encodeParams(preparedParams)
+      : concat(preparedParams.map(({ encoded }) => encoded)),
+  }
+}
+
+export function getArrayComponents(
+  type: string,
+): [length: number | null, innerType: string] | undefined {
+  const matches = type.match(/^(.*)\[(\d+)?\]$/)
+  return matches
+    ? // Return `null` if the array is dynamic.
+      [matches[2] ? Number(matches[2]) : null, matches[1]]
+    : undefined
+}

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

@@ -0,0 +1,131 @@
+import { expect, test } from 'vitest'
+
+import { encodeDeployData } from './encodeDeployData'
+
+test('constructor()', () => {
+  expect(
+    encodeDeployData({
+      abi: [
+        {
+          inputs: [],
+          stateMutability: 'nonpayable',
+          type: 'constructor',
+        },
+      ] as const,
+      bytecode:
+        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+    }),
+  ).toEqual(
+    '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+  )
+  expect(
+    encodeDeployData({
+      // @ts-expect-error
+      abi: [
+        {
+          stateMutability: 'nonpayable',
+          type: 'constructor',
+        },
+      ] as const,
+      bytecode:
+        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+    }),
+  ).toEqual(
+    '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+  )
+})
+
+test('constructor(uint256)', () => {
+  expect(
+    encodeDeployData({
+      abi: [
+        {
+          inputs: [
+            {
+              internalType: 'uint256',
+              name: 'a',
+              type: 'uint256',
+            },
+          ],
+          stateMutability: 'nonpayable',
+          type: 'constructor',
+        },
+      ] as const,
+      bytecode:
+        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+      args: [69420n],
+    }),
+  ).toEqual(
+    '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c634300080700330000000000000000000000000000000000000000000000000000000000010f2c',
+  )
+})
+
+test('error: constructor not found', () => {
+  expect(() =>
+    encodeDeployData({
+      // @ts-expect-error
+      abi: [{}] as const,
+      bytecode:
+        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+      args: [69420n],
+    }),
+  ).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/encodeDeployData
+
+    Version: viem@1.0.2"
+  `)
+})
+
+test('error: no inputs', () => {
+  expect(() =>
+    encodeDeployData({
+      // @ts-expect-error
+      abi: [
+        {
+          stateMutability: 'nonpayable',
+          type: 'constructor',
+        },
+      ] as const,
+      bytecode:
+        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+      args: [69420n],
+    }),
+  ).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/encodeDeployData
+
+    Version: viem@1.0.2"
+  `,
+  )
+
+  expect(() =>
+    encodeDeployData({
+      // @ts-expect-error
+      abi: [
+        {
+          inputs: undefined,
+          stateMutability: 'nonpayable',
+          type: 'constructor',
+        },
+      ] as const,
+      bytecode:
+        '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
+      args: [69420n],
+    }),
+  ).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/encodeDeployData
+
+    Version: viem@1.0.2"
+  `,
+  )
+})

package/src/utils/abi/encodeDeployData.ts

@@ -0,0 +1,37 @@
+import { Abi } from 'abitype'
+
+import {
+  AbiConstructorNotFoundError,
+  AbiConstructorParamsNotFoundError,
+} from '../../errors'
+import { ExtractConstructorArgsFromAbi, Hex } from '../../types'
+import { concatHex } from '../data'
+import { encodeAbi } from './encodeAbi'
+
+const docsPath = '/docs/contract/encodeDeployData'
+
+export type EncodeDeployDataArgs<TAbi extends Abi = Abi> = {
+  abi: TAbi
+  bytecode: Hex
+} & ExtractConstructorArgsFromAbi<TAbi>
+
+export function encodeDeployData<TAbi extends Abi = Abi>({
+  abi,
+  args,
+  bytecode,
+}: EncodeDeployDataArgs<TAbi>) {
+  if (!args || args.length === 0) 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 data = encodeAbi({
+    params: description.inputs,
+    values: args as any,
+  })
+  return concatHex([bytecode, data!])
+}

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

@@ -0,0 +1,197 @@
+import { expect, test } from 'vitest'
+
+import { encodeErrorResult } from './encodeErrorResult'
+
+test('revert SoldOutError()', () => {
+  expect(
+    encodeErrorResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'SoldOutError',
+          type: 'error',
+        },
+      ],
+      errorName: 'SoldOutError',
+    }),
+  ).toEqual('0x7f6df6bb')
+  expect(
+    encodeErrorResult({
+      abi: [
+        // @ts-expect-error
+        {
+          name: 'SoldOutError',
+          type: 'error',
+        },
+      ],
+      errorName: 'SoldOutError',
+    }),
+  ).toEqual('0x7f6df6bb')
+})
+
+test('revert AccessDeniedError(string)', () => {
+  expect(
+    encodeErrorResult({
+      abi: [
+        {
+          inputs: [
+            {
+              internalType: 'string',
+              name: 'a',
+              type: 'string',
+            },
+          ],
+          name: 'AccessDeniedError',
+          type: 'error',
+        },
+      ] as const,
+      errorName: 'AccessDeniedError',
+      args: ['you do not have access ser'],
+    }),
+  ).toEqual(
+    '0x83aa206e0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001a796f7520646f206e6f7420686176652061636365737320736572000000000000',
+  )
+})
+
+test('revert AccessDeniedError((uint256,bool,address,uint256))', () => {
+  expect(
+    encodeErrorResult({
+      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',
+        },
+      ],
+      errorName: 'AccessDeniedError',
+      args: [
+        {
+          delegate: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+          vote: 41n,
+          voted: true,
+          weight: 69420n,
+        },
+      ],
+    }),
+  ).toEqual(
+    '0x0a1895610000000000000000000000000000000000000000000000000000000000010f2c0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac0000000000000000000000000000000000000000000000000000000000000029',
+  )
+})
+
+test("errors: error doesn't exist", () => {
+  expect(() =>
+    encodeErrorResult({
+      abi: [
+        {
+          inputs: [],
+          name: 'SoldOutError',
+          type: 'error',
+        },
+      ],
+      errorName: 'AccessDeniedError',
+      args: [
+        {
+          delegate: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+          vote: 41n,
+          voted: true,
+          weight: 69420n,
+        },
+      ],
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "Error \\"AccessDeniedError\\" not found on ABI.
+    Make sure you are using the correct ABI and that the error exists on it.
+
+    Docs: https://viem.sh/docs/contract/encodeErrorResult
+
+    Version: viem@1.0.2"
+  `)
+})
+
+test('errors: no inputs', () => {
+  expect(() =>
+    encodeErrorResult({
+      abi: [
+        // @ts-expect-error
+        {
+          name: 'AccessDeniedError',
+          type: 'error',
+        },
+      ],
+      errorName: 'AccessDeniedError',
+      args: [
+        {
+          delegate: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+          vote: 41n,
+          voted: true,
+          weight: 69420n,
+        },
+      ],
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "Arguments (\`args\`) were provided to \\"AccessDeniedError\\", but \\"AccessDeniedError\\" on the ABI does not contain any parameters (\`inputs\`).
+    Cannot encode error result without knowing what the parameter types are.
+    Make sure you are using the correct ABI and that the inputs exist on it.
+
+    Docs: https://viem.sh/docs/contract/encodeErrorResult
+
+    Version: viem@1.0.2"
+  `)
+  expect(() =>
+    encodeErrorResult({
+      abi: [
+        {
+          // @ts-expect-error
+          inputs: undefined,
+          name: 'AccessDeniedError',
+          type: 'error',
+        },
+      ],
+      errorName: 'AccessDeniedError',
+      args: [
+        {
+          delegate: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+          vote: 41n,
+          voted: true,
+          weight: 69420n,
+        },
+      ],
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "Arguments (\`args\`) were provided to \\"AccessDeniedError\\", but \\"AccessDeniedError\\" on the ABI does not contain any parameters (\`inputs\`).
+    Cannot encode error result without knowing what the parameter types are.
+    Make sure you are using the correct ABI and that the inputs exist on it.
+
+    Docs: https://viem.sh/docs/contract/encodeErrorResult
+
+    Version: viem@1.0.2"
+  `)
+})

package/src/utils/abi/encodeErrorResult.ts

@@ -0,0 +1,40 @@
+import { Abi, ExtractAbiErrorNames } from 'abitype'
+import {
+  AbiErrorInputsNotFoundError,
+  AbiErrorNotFoundError,
+} from '../../errors'
+
+import { ExtractErrorArgsFromAbi, Hex } from '../../types'
+import { concatHex } from '../data'
+import { getFunctionSignature } from '../hash'
+import { encodeAbi } from './encodeAbi'
+import { formatAbiItem } from './formatAbiItem'
+import { getAbiItem } from './getAbiItem'
+
+const docsPath = '/docs/contract/encodeErrorResult'
+
+export type EncodeErrorResultArgs<
+  TAbi extends Abi = Abi,
+  TErrorName extends ExtractAbiErrorNames<TAbi> = any,
+> = {
+  abi: TAbi
+  errorName: TErrorName
+} & ExtractErrorArgsFromAbi<TAbi, TErrorName>
+
+export function encodeErrorResult<
+  TAbi extends Abi = Abi,
+  TErrorName extends ExtractAbiErrorNames<TAbi> = any,
+>({ abi, errorName, args }: EncodeErrorResultArgs<TAbi, TErrorName>) {
+  const description = getAbiItem({ abi, name: errorName })
+  if (!description) throw new AbiErrorNotFoundError(errorName, { docsPath })
+  const definition = formatAbiItem(description)
+  const signature = getFunctionSignature(definition)
+
+  let data: Hex = '0x'
+  if (args && args.length > 0) {
+    if (!('inputs' in description && description.inputs))
+      throw new AbiErrorInputsNotFoundError(errorName, { docsPath })
+    data = encodeAbi({ params: description.inputs, values: args as any })
+  }
+  return concatHex([signature, data])
+}