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

package/src/utils/abi/encodeAbi.ts

@@ -1,273 +0,0 @@
-import {
-  AbiParameter,
-  AbiParametersToPrimitiveTypes,
-  AbiParameterToPrimitiveType,
-  Narrow,
-} 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[]
-    | readonly unknown[] = readonly AbiParameter[],
-> = {
-  params: Narrow<TParams>
-  values: TParams extends readonly AbiParameter[]
-    ? AbiParametersToPrimitiveTypes<TParams>
-    : never
-}
-
-/**
- * @description Encodes a list of primitive values into an ABI-encoded hex value.
- */
-export function encodeAbi<
-  TParams extends readonly AbiParameter[] | readonly unknown[],
->({ params, values }: EncodeAbiArgs<TParams>) {
-  if (params.length !== values.length)
-    throw new AbiEncodingLengthMismatchError({
-      expectedLength: params.length as number,
-      givenLength: values.length,
-    })
-  // Prepare the parameters to determine dynamic types to encode.
-  const preparedParams = prepareParams({
-    params: params as readonly AbiParameter[],
-    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: Narrow<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

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

@@ -1,40 +0,0 @@
-import { Abi, Narrow } 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 | readonly unknown[] = Abi> =
-  {
-    abi: Narrow<TAbi>
-    bytecode: Hex
-  } & ExtractConstructorArgsFromAbi<TAbi>
-
-export function encodeDeployData<TAbi extends Abi | readonly unknown[]>({
-  abi,
-  args,
-  bytecode,
-}: EncodeDeployDataArgs<TAbi>) {
-  if (!args || args.length === 0) 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 data = encodeAbi({
-    params: description.inputs,
-    values: args as any,
-  })
-  return concatHex([bytecode, data!])
-}

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

@@ -1,192 +0,0 @@
-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: [
-        {
-          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',
-        },
-      ],
-      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',
-        },
-      ],
-      // @ts-expect-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: [
-        {
-          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: [
-        {
-          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

@@ -1,47 +0,0 @@
-import { Abi, Narrow } from 'abitype'
-import {
-  AbiErrorInputsNotFoundError,
-  AbiErrorNotFoundError,
-} from '../../errors'
-import {
-  ExtractErrorArgsFromAbi,
-  ExtractErrorNameFromAbi,
-  Hex,
-} from '../../types'
-import { concatHex } from '../data'
-import { getFunctionSignature } from '../hash'
-import { encodeAbi } from './encodeAbi'
-import { formatAbiItem } from './formatAbiItem'
-import { getAbiItem, GetAbiItemArgs } from './getAbiItem'
-
-const docsPath = '/docs/contract/encodeErrorResult'
-
-export type EncodeErrorResultArgs<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TErrorName extends string = string,
-> = {
-  abi: Narrow<TAbi>
-  errorName: ExtractErrorNameFromAbi<TAbi, TErrorName>
-} & ExtractErrorArgsFromAbi<TAbi, TErrorName>
-
-export function encodeErrorResult<
-  TAbi extends Abi | readonly unknown[],
-  TErrorName extends string,
->({ abi, errorName, args }: EncodeErrorResultArgs<TAbi, TErrorName>) {
-  const description = getAbiItem({
-    abi,
-    args,
-    name: errorName,
-  } as GetAbiItemArgs)
-  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])
-}