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

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

@@ -0,0 +1,335 @@
+import { expect, test } from 'vitest'
+
+import { formatAbiItemWithParams } from './formatAbiItemWithParams'
+
+test('foo()', () => {
+  expect(
+    // @ts-expect-error
+    formatAbiItemWithParams({
+      name: 'foo',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    }),
+  ).toEqual('foo()')
+  expect(
+    formatAbiItemWithParams({
+      inputs: [],
+      name: 'foo',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    }),
+  ).toEqual('foo()')
+})
+
+test('foo(uint256)', () => {
+  expect(
+    formatAbiItemWithParams({
+      inputs: [
+        {
+          internalType: 'uint256',
+          name: 'a',
+          type: 'uint256',
+        },
+      ],
+      name: 'foo',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    }),
+  ).toEqual('foo(uint256)')
+  expect(
+    formatAbiItemWithParams(
+      {
+        inputs: [
+          {
+            internalType: 'uint256',
+            name: 'a',
+            type: 'uint256',
+          },
+        ],
+        name: 'foo',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'function',
+      },
+      { includeName: true },
+    ),
+  ).toEqual('foo(uint256 a)')
+})
+
+test('getVoter((uint256,bool,address,uint256),string[],bytes)', () => {
+  expect(
+    formatAbiItemWithParams({
+      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',
+        },
+        {
+          internalType: 'string[]',
+          name: 'foo',
+          type: 'string[]',
+        },
+        {
+          internalType: 'bytes',
+          name: 'bar',
+          type: 'bytes',
+        },
+      ],
+      name: 'getVoter',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'function',
+    }),
+  ).toEqual('getVoter((uint256,bool,address,uint256),string[],bytes)')
+  expect(
+    formatAbiItemWithParams(
+      {
+        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',
+          },
+          {
+            internalType: 'string[]',
+            name: 'foo',
+            type: 'string[]',
+          },
+          {
+            internalType: 'bytes',
+            name: 'bar',
+            type: 'bytes',
+          },
+        ],
+        name: 'getVoter',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'function',
+      },
+      { includeName: true },
+    ),
+  ).toEqual(
+    'getVoter((uint256 weight, bool voted, address delegate, uint256 vote), string[] foo, bytes bar)',
+  )
+})
+
+test('VoterEvent((uint256,bool,address,uint256),string[],bytes)', () => {
+  expect(
+    formatAbiItemWithParams({
+      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',
+        },
+        {
+          internalType: 'string[]',
+          name: 'foo',
+          type: 'string[]',
+        },
+        {
+          internalType: 'bytes',
+          name: 'bar',
+          type: 'bytes',
+        },
+      ],
+      name: 'VoterEvent',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'event',
+    }),
+  ).toEqual('VoterEvent((uint256,bool,address,uint256),string[],bytes)')
+  expect(
+    formatAbiItemWithParams(
+      {
+        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',
+          },
+          {
+            internalType: 'string[]',
+            name: 'foo',
+            type: 'string[]',
+          },
+          {
+            internalType: 'bytes',
+            name: 'bar',
+            type: 'bytes',
+          },
+        ],
+        name: 'VoterEvent',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'event',
+      },
+      { includeName: true },
+    ),
+  ).toEqual(
+    'VoterEvent((uint256 weight, bool voted, address delegate, uint256 vote), string[] foo, bytes bar)',
+  )
+})
+
+test('VoterError((uint256,bool,address,uint256),string[],bytes)', () => {
+  expect(
+    formatAbiItemWithParams({
+      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',
+        },
+        {
+          internalType: 'string[]',
+          name: 'foo',
+          type: 'string[]',
+        },
+        {
+          internalType: 'bytes',
+          name: 'bar',
+          type: 'bytes',
+        },
+      ],
+      name: 'VoterError',
+      outputs: [],
+      stateMutability: 'nonpayable',
+      type: 'error',
+    }),
+  ).toEqual('VoterError((uint256,bool,address,uint256),string[],bytes)')
+})
+
+test('error: invalid type', () => {
+  expect(() =>
+    formatAbiItemWithParams({
+      inputs: [
+        {
+          internalType: 'bytes32[]',
+          name: 'proposalNames',
+          type: 'bytes32[]',
+        },
+      ],
+      stateMutability: 'nonpayable',
+      type: 'constructor',
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "\\"constructor\\" is not a valid definition type.
+    Valid types: \\"function\\", \\"event\\", \\"error\\"
+
+    Version: viem@1.0.2"
+  `)
+})

package/src/utils/abi/formatAbiItemWithParams.ts

@@ -0,0 +1,41 @@
+import { AbiParameter } from 'abitype'
+
+import { InvalidDefinitionTypeError } from '../../errors'
+import { AbiItem } from '../../types'
+
+export function formatAbiItemWithParams(
+  abiItem: AbiItem,
+  { includeName = false }: { includeName?: boolean } = {},
+) {
+  if (
+    abiItem.type !== 'function' &&
+    abiItem.type !== 'event' &&
+    abiItem.type !== 'error'
+  )
+    throw new InvalidDefinitionTypeError(abiItem.type)
+
+  return `${abiItem.name}(${getParams(abiItem.inputs, { includeName })})`
+}
+
+function getParams(
+  params: readonly AbiParameter[] | undefined,
+  { includeName }: { includeName: boolean },
+): string {
+  if (!params) return ''
+  return params
+    .map((param) => getParam(param, { includeName }))
+    .join(includeName ? ', ' : ',')
+}
+
+function getParam(
+  param: AbiParameter,
+  { includeName }: { includeName: boolean },
+): string {
+  if (param.type.startsWith('tuple')) {
+    return `(${getParams(
+      (param as unknown as { components: AbiParameter[] }).components,
+      { includeName },
+    )})${param.type.slice('tuple'.length)}`
+  }
+  return param.type + (includeName && param.name ? ` ${param.name}` : '')
+}

package/src/utils/abi/getAbiItem.ts

@@ -0,0 +1,5 @@
+import { Abi } from 'abitype'
+
+export function getAbiItem({ abi, name }: { abi: Abi; name: string }) {
+  return abi.find((x) => 'name' in x && x.name === name)
+}

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

@@ -0,0 +1,23 @@
+import { expect, test } from 'vitest'
+
+import * as utils from './index'
+
+test('exports utils', () => {
+  expect(utils).toMatchInlineSnapshot(`
+    {
+      "decodeAbi": [Function],
+      "decodeErrorResult": [Function],
+      "decodeFunctionData": [Function],
+      "decodeFunctionResult": [Function],
+      "encodeAbi": [Function],
+      "encodeDeployData": [Function],
+      "encodeErrorResult": [Function],
+      "encodeEventTopics": [Function],
+      "encodeFunctionData": [Function],
+      "encodeFunctionResult": [Function],
+      "formatAbiItemWithArgs": [Function],
+      "formatAbiItemWithParams": [Function],
+      "getAbiItem": [Function],
+    }
+  `)
+})

package/src/utils/abi/index.ts

@@ -0,0 +1,38 @@
+export type { DecodeAbiArgs } from './decodeAbi'
+export { decodeAbi } from './decodeAbi'
+
+export type { DecodeErrorResultArgs } from './decodeErrorResult'
+export { decodeErrorResult } from './decodeErrorResult'
+
+export type { DecodeFunctionDataArgs } from './decodeFunctionData'
+export { decodeFunctionData } from './decodeFunctionData'
+
+export type {
+  DecodeFunctionResultArgs,
+  DecodeFunctionResultResponse,
+} from './decodeFunctionResult'
+export { decodeFunctionResult } from './decodeFunctionResult'
+
+export type { EncodeAbiArgs } from './encodeAbi'
+export { encodeAbi } from './encodeAbi'
+
+export type { EncodeDeployDataArgs } from './encodeDeployData'
+export { encodeDeployData } from './encodeDeployData'
+
+export type { EncodeErrorResultArgs } from './encodeErrorResult'
+export { encodeErrorResult } from './encodeErrorResult'
+
+export type { EncodeEventTopicsArgs } from './encodeEventTopics'
+export { encodeEventTopics } from './encodeEventTopics'
+
+export type { EncodeFunctionDataArgs } from './encodeFunctionData'
+export { encodeFunctionData } from './encodeFunctionData'
+
+export type { EncodeFunctionResultArgs } from './encodeFunctionResult'
+export { encodeFunctionResult } from './encodeFunctionResult'
+
+export { formatAbiItemWithArgs } from './formatAbiItemWithArgs'
+
+export { formatAbiItemWithParams } from './formatAbiItemWithParams'
+
+export { getAbiItem } from './getAbiItem'

package/src/utils/address/getAddress.bench.ts

@@ -0,0 +1,22 @@
+import { bench, describe } from 'vitest'
+import { utils } from 'ethers'
+
+import Web3 from 'web3'
+
+import { getAddress } from './getAddress'
+
+describe('Get Address', () => {
+  bench('viem: getAddress', () => {
+    getAddress('0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC')
+  })
+
+  bench('ethers: getAddress', () => {
+    utils.getAddress('0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC')
+  })
+
+  bench('web3.js: checkAddressChecksum', () => {
+    Web3.utils.checkAddressChecksum(
+      '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+    )
+  })
+})

package/src/utils/address/getAddress.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from 'vitest'
+
+import { getAddress } from './getAddress'
+
+test('checksums address', () => {
+  expect(
+    getAddress('0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678ac'),
+  ).toMatchInlineSnapshot('"0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC"')
+  expect(
+    getAddress('0xa0cf798816d4b9b9866b5330eea46a18382f251e'),
+  ).toMatchInlineSnapshot('"0xA0Cf798816D4b9b9866b5330EEa46a18382f251e"')
+  expect(
+    getAddress('0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266'),
+  ).toMatchInlineSnapshot('"0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"')
+  expect(
+    getAddress('0x70997970c51812dc3a010c7d01b50e0d17dc79c8'),
+  ).toMatchInlineSnapshot('"0x70997970C51812dc3A010C7d01b50e0d17dc79C8"')
+  expect(
+    getAddress('0x3c44cdddb6a900fa2b585dd299e03d12fa4293bc'),
+  ).toMatchInlineSnapshot('"0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC"')
+  expect(
+    getAddress('0x90f79bf6eb2c4f870365e785982e1f101e93b906'),
+  ).toMatchInlineSnapshot('"0x90F79bf6EB2c4f870365E785982E1f101E93b906"')
+  expect(
+    getAddress('0x15d34aaf54267db7d7c367839aaf71a00a2c6a65'),
+  ).toMatchInlineSnapshot('"0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65"')
+})
+
+describe('errors', () => {
+  test('invalid address', () => {
+    expect(() =>
+      getAddress('0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678az'),
+    ).toThrowErrorMatchingInlineSnapshot(`
+        "Address \\"0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678az\\" is invalid.
+
+        Version: viem@1.0.2"
+      `)
+    expect(() =>
+      getAddress('0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678aff'),
+    ).toThrowErrorMatchingInlineSnapshot(`
+        "Address \\"0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678aff\\" is invalid.
+
+        Version: viem@1.0.2"
+      `)
+  })
+})

package/src/utils/address/getAddress.ts

@@ -0,0 +1,28 @@
+import { InvalidAddressError } from '../../errors'
+import type { Address } from '../../types'
+import { stringToBytes } from '../encoding'
+import { keccak256 } from '../hash'
+
+const addressRegex = /^(0x)?[a-fA-F0-9]{40}$/
+
+export function checksumAddress(address_: Address): Address {
+  const hexAddress = address_.substring(2).toLowerCase()
+  const hash = keccak256(stringToBytes(hexAddress), 'bytes')
+
+  let address = hexAddress.split('')
+  for (let i = 0; i < 40; i += 2) {
+    if (hash?.[i >> 1] >> 4 >= 8 && address[i]) {
+      address[i] = address[i].toUpperCase()
+    }
+    if ((hash[i >> 1] & 0x0f) >= 8 && address[i + 1]) {
+      address[i + 1] = address[i + 1].toUpperCase()
+    }
+  }
+
+  return `0x${address.join('')}`
+}
+
+export function getAddress(address: Address) {
+  if (!addressRegex.test(address)) throw new InvalidAddressError({ address })
+  return checksumAddress(address)
+}

package/src/utils/address/getContractAddress.bench.ts

@@ -0,0 +1,20 @@
+import { bench, describe } from 'vitest'
+import { utils } from 'ethers'
+
+import { getContractAddress } from './getContractAddress'
+
+describe('Get Contract Address (CREATE)', () => {
+  bench('viem: getContractAddress', () => {
+    getContractAddress({
+      from: '0xc961145a54C96E3aE9bAA048c4F4D6b04C13916b',
+      nonce: 69420n,
+    })
+  })
+
+  bench('ethers: getContractAddress', () => {
+    utils.getContractAddress({
+      from: '0xc961145a54C96E3aE9bAA048c4F4D6b04C13916b',
+      nonce: 69420n,
+    })
+  })
+})