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

package/src/utils/contract/extractFunctionParts.test.ts

@@ -0,0 +1,109 @@
+import { expect, test } from 'vitest'
+
+import {
+  extractFunctionName,
+  extractFunctionParams,
+  extractFunctionParts,
+  extractFunctionType,
+} from './extractFunctionParts'
+
+test('extractFunctionParts', () => {
+  expect(extractFunctionParts('foo()')).toMatchInlineSnapshot(`
+    {
+      "name": "foo",
+      "params": undefined,
+      "type": undefined,
+    }
+  `)
+  expect(extractFunctionParts('bar(uint foo)')).toMatchInlineSnapshot(`
+    {
+      "name": "bar",
+      "params": "uint foo",
+      "type": undefined,
+    }
+  `)
+  expect(
+    extractFunctionParts('function bar(uint foo, address baz)'),
+  ).toMatchInlineSnapshot(`
+      {
+        "name": "bar",
+        "params": "uint foo, address baz",
+        "type": "function",
+      }
+    `)
+  expect(extractFunctionParts('event Baz()')).toMatchInlineSnapshot(`
+    {
+      "name": "Baz",
+      "params": undefined,
+      "type": "event",
+    }
+  `)
+  expect(extractFunctionParts('event Barry(uint foo)')).toMatchInlineSnapshot(
+    `
+    {
+      "name": "Barry",
+      "params": "uint foo",
+      "type": "event",
+    }
+  `,
+  )
+})
+
+test('extractFunctionName', () => {
+  expect(extractFunctionName('foo()')).toBe('foo')
+  expect(extractFunctionName('bar(uint foo)')).toBe('bar')
+  expect(extractFunctionName('event Baz()')).toBe('Baz')
+  expect(extractFunctionName('event Barry(uint foo)')).toBe('Barry')
+})
+
+test('extractFunctionType', () => {
+  expect(extractFunctionType('foo()')).toBeUndefined()
+  expect(extractFunctionType('function bar(uint foo)')).toBe('function')
+  expect(extractFunctionType('event Barry(uint foo)')).toBe('event')
+})
+
+test('extractFunctionParams', () => {
+  expect(extractFunctionParams('foo()')).toMatchInlineSnapshot('undefined')
+  expect(
+    extractFunctionParams('bar(uint foo, address baz)'),
+  ).toMatchInlineSnapshot(`
+    [
+      {
+        "name": "foo",
+        "type": "uint",
+      },
+      {
+        "name": "baz",
+        "type": "address",
+      },
+    ]
+  `)
+  expect(
+    extractFunctionParams('bar(uint indexed foo, address baz)'),
+  ).toMatchInlineSnapshot(`
+    [
+      {
+        "indexed": true,
+        "name": "foo",
+        "type": "uint",
+      },
+      {
+        "name": "baz",
+        "type": "address",
+      },
+    ]
+  `)
+  expect(extractFunctionParams('event Baz()')).toMatchInlineSnapshot(
+    'undefined',
+  )
+  expect(extractFunctionParams('event Barry(uint foo)')).toMatchInlineSnapshot(
+    `
+    [
+      {
+        "name": "foo",
+        "type": "uint",
+      },
+    ]
+  `,
+  )
+})

package/src/utils/contract/extractFunctionParts.ts

@@ -0,0 +1,27 @@
+const paramsRegex = /((function|event)\s)?(.*)(\((.*)\))/
+
+export function extractFunctionParts(def: string) {
+  const parts = def.match(paramsRegex)
+  const type = parts?.[2] || undefined
+  const name = parts?.[3]
+  const params = parts?.[5] || undefined
+  return { type, name, params }
+}
+
+export function extractFunctionName(def: string) {
+  return extractFunctionParts(def).name
+}
+
+export function extractFunctionParams(def: string) {
+  const params = extractFunctionParts(def).params
+  const splitParams = params?.split(',').map((x) => x.trim().split(' '))
+  return splitParams?.map((param) => ({
+    type: param[0],
+    name: param[1] === 'indexed' ? param[2] : param[1],
+    ...(param[1] === 'indexed' ? { indexed: true } : {}),
+  }))
+}
+
+export function extractFunctionType(def: string) {
+  return extractFunctionParts(def).type
+}

package/src/utils/contract/getContractError.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from 'vitest'
+
+import { accounts } from '../../_test'
+import { baycContractConfig } from '../../_test/abis'
+import { BaseError } from '../../errors'
+import { getContractError } from './getContractError'
+
+describe('getContractError', () => {
+  test('default', () => {
+    expect(
+      getContractError(
+        new BaseError('An RPC error occurred', {
+          cause: {
+            code: 3,
+            message: 'execution reverted: Sale must be active to mint Ape',
+            data: '0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001f53616c65206d7573742062652061637469766520746f206d696e742041706500',
+          } as unknown as Error,
+        }),
+        {
+          abi: baycContractConfig.abi,
+          functionName: 'mintApe',
+          args: [1n],
+          sender: accounts[0].address,
+        },
+      ),
+    ).toMatchInlineSnapshot(`
+      [ContractMethodExecutionError: Sale must be active to mint Ape
+       
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+      Function:  mintApe(uint256 numberOfTokens)
+      Arguments:        (1)
+
+      Details: execution reverted: Sale must be active to mint Ape
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('default', () => {
+    expect(
+      getContractError(
+        new BaseError('An RPC error occurred', {
+          cause: {
+            code: 3,
+            message: 'execution reverted: Sale must be active to mint Ape',
+            data: '0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001f53616c65206d7573742062652061637469766520746f206d696e742041706500',
+          } as unknown as Error,
+        }),
+        {
+          abi: baycContractConfig.abi,
+          functionName: 'foo',
+          args: [1n],
+          sender: accounts[0].address,
+        },
+      ),
+    ).toMatchInlineSnapshot(`
+      [ContractMethodExecutionError: Sale must be active to mint Ape
+       
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+
+      Details: execution reverted: Sale must be active to mint Ape
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('unknown error', () => {
+    expect(
+      getContractError(
+        new BaseError('An RPC error occurred', {
+          cause: new Error('rarararar i am an error lmaoaoo'),
+        }),
+        {
+          abi: baycContractConfig.abi,
+          functionName: 'foo',
+          args: [1n],
+          sender: accounts[0].address,
+        },
+      ),
+    ).toMatchInlineSnapshot(`
+      [ViemError: An RPC error occurred
+
+      Details: rarararar i am an error lmaoaoo
+      Version: viem@1.0.2]
+    `)
+    expect(
+      getContractError(new BaseError('An RPC error occurred'), {
+        abi: baycContractConfig.abi,
+        functionName: 'foo',
+        args: [1n],
+        sender: accounts[0].address,
+      }),
+    ).toMatchInlineSnapshot(`
+      [ViemError: An RPC error occurred
+
+      Version: viem@1.0.2]
+    `)
+  })
+})

package/src/utils/contract/getContractError.ts

@@ -0,0 +1,66 @@
+import { Abi } from 'abitype'
+import {
+  AbiDecodingZeroDataError,
+  ContractMethodExecutionError,
+  ContractMethodZeroDataError,
+} from '../../errors'
+import { Address } from '../../types'
+import { formatAbiItemWithArgs, formatAbiItem, getAbiItem } from '../abi'
+
+export function getContractError(
+  err: unknown,
+  {
+    abi,
+    address,
+    args,
+    functionName,
+    sender,
+  }: {
+    abi: Abi
+    args: any
+    address?: Address
+    functionName: string
+    sender?: Address
+  },
+) {
+  const { code, message } =
+    ((err as Error).cause as { code?: number; message?: string }) || {}
+
+  const abiItem = getAbiItem({ abi, name: functionName })
+  const formattedArgs = abiItem
+    ? formatAbiItemWithArgs({
+        abiItem,
+        args,
+        includeFunctionName: false,
+        includeName: false,
+      })
+    : undefined
+  const functionWithParams = abiItem
+    ? formatAbiItem(abiItem, { includeName: true })
+    : undefined
+
+  if (err instanceof AbiDecodingZeroDataError) {
+    return new ContractMethodZeroDataError({
+      abi,
+      args,
+      cause: err as Error,
+      contractAddress: address,
+      functionName,
+      functionWithParams,
+    })
+  }
+  if (code === 3 || message?.includes('execution reverted')) {
+    const message_ = message?.replace('execution reverted: ', '')
+    return new ContractMethodExecutionError(message_, {
+      abi,
+      args,
+      cause: err as Error,
+      contractAddress: address,
+      formattedArgs,
+      functionName,
+      functionWithParams,
+      sender,
+    })
+  }
+  return err
+}

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

@@ -0,0 +1,15 @@
+import { expect, test } from 'vitest'
+
+import * as utils from './index'
+
+test('exports utils', () => {
+  expect(utils).toMatchInlineSnapshot(`
+    {
+      "extractFunctionName": [Function],
+      "extractFunctionParams": [Function],
+      "extractFunctionParts": [Function],
+      "extractFunctionType": [Function],
+      "getContractError": [Function],
+    }
+  `)
+})

package/src/utils/contract/index.ts

@@ -0,0 +1,8 @@
+export {
+  extractFunctionName,
+  extractFunctionParams,
+  extractFunctionParts,
+  extractFunctionType,
+} from './extractFunctionParts'
+
+export { getContractError } from './getContractError'

package/src/utils/data/concat.test.ts

@@ -0,0 +1,35 @@
+import { expect, test } from 'vitest'
+
+import { concat, concatBytes, concatHex } from './concat'
+
+test('concat', () => {
+  expect(concat(['0x0', '0x1'])).toBe('0x01')
+  expect(concat(['0x1', '0x69', '0x420'])).toBe('0x169420')
+  expect(concat(['0x00000001', '0x00000069', '0x00000420'])).toBe(
+    '0x000000010000006900000420',
+  )
+  expect(concatHex(['0x00000001', '0x00000069', '0x00000420'])).toBe(
+    '0x000000010000006900000420',
+  )
+
+  expect(concat([new Uint8Array([0]), new Uint8Array([1])])).toStrictEqual(
+    new Uint8Array([0, 1]),
+  )
+  expect(concatBytes([new Uint8Array([0]), new Uint8Array([1])])).toStrictEqual(
+    new Uint8Array([0, 1]),
+  )
+  expect(
+    concat([
+      new Uint8Array([1]),
+      new Uint8Array([69]),
+      new Uint8Array([420, 69]),
+    ]),
+  ).toStrictEqual(new Uint8Array([1, 69, 420, 69]))
+  expect(
+    concat([
+      new Uint8Array([0, 0, 0, 1]),
+      new Uint8Array([0, 0, 0, 69]),
+      new Uint8Array([0, 0, 420, 69]),
+    ]),
+  ).toStrictEqual(new Uint8Array([0, 0, 0, 1, 0, 0, 0, 69, 0, 0, 420, 69]))
+})

package/src/utils/data/concat.ts

@@ -0,0 +1,34 @@
+import type { ByteArray, Hex } from '../../types'
+
+type ConcatResult<TValue extends Hex | ByteArray> = TValue extends Hex
+  ? Hex
+  : ByteArray
+
+export function concat<TValue extends Hex | ByteArray>(
+  values: TValue[],
+): ConcatResult<TValue> {
+  if (typeof values[0] === 'string')
+    return concatHex(values as Hex[]) as ConcatResult<TValue>
+  return concatBytes(values as ByteArray[]) as ConcatResult<TValue>
+}
+
+export function concatBytes(values: ByteArray[]): ByteArray {
+  let length = 0
+  for (const arr of values) {
+    length += arr.length
+  }
+  const result = new Uint8Array(length)
+  let offset = 0
+  for (const arr of values) {
+    result.set(arr, offset)
+    offset += arr.length
+  }
+  return result
+}
+
+export function concatHex(values: Hex[]): Hex {
+  return `0x${(values as Hex[]).reduce(
+    (acc, x) => acc + x.replace('0x', ''),
+    '',
+  )}`
+}

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

@@ -0,0 +1,23 @@
+import { expect, test } from 'vitest'
+
+import * as utils from './index'
+
+test('exports utils', () => {
+  expect(utils).toMatchInlineSnapshot(`
+    {
+      "concat": [Function],
+      "concatBytes": [Function],
+      "concatHex": [Function],
+      "isBytes": [Function],
+      "isHex": [Function],
+      "pad": [Function],
+      "padBytes": [Function],
+      "padHex": [Function],
+      "size": [Function],
+      "slice": [Function],
+      "sliceBytes": [Function],
+      "sliceHex": [Function],
+      "trim": [Function],
+    }
+  `)
+})

package/src/utils/data/index.ts

@@ -0,0 +1,13 @@
+export { concat, concatBytes, concatHex } from './concat'
+
+export { isBytes } from './isBytes'
+
+export { isHex } from './isHex'
+
+export { pad, padBytes, padHex } from './pad'
+
+export { trim } from './trim'
+
+export { size } from './size'
+
+export { slice, sliceBytes, sliceHex } from './slice'

package/src/utils/data/isBytes.test.ts

@@ -0,0 +1,9 @@
+import { expect, test } from 'vitest'
+
+import { isBytes } from './isBytes'
+
+test('is bytes', () => {
+  expect(isBytes(new Uint8Array([1, 69, 420])))
+  expect(isBytes('0x1')).toBeFalsy()
+  expect(isBytes(undefined)).toBeFalsy()
+})

package/src/utils/data/isBytes.ts

@@ -0,0 +1,7 @@
+export function isBytes(value: any) {
+  if (!value) return false
+  if (typeof value !== 'object') return false
+  return (
+    value.BYTES_PER_ELEMENT === 1 && value.constructor.name === 'Uint8Array'
+  )
+}

package/src/utils/data/isHex.test.ts

@@ -0,0 +1,13 @@
+import { expect, test } from 'vitest'
+
+import { isHex } from './isHex'
+
+test('is hex', () => {
+  expect(isHex('0x')).toBeTruthy()
+  expect(isHex('0x0')).toBeTruthy()
+  expect(isHex('0x0123456789abcdef')).toBeTruthy()
+  expect(isHex('0x0123456789abcdefABCDEF')).toBeTruthy()
+  expect(isHex('0x0123456789abcdefg')).toBeFalsy()
+  expect(isHex({ foo: 'bar' })).toBeFalsy()
+  expect(isHex(undefined)).toBeFalsy()
+})

package/src/utils/data/isHex.ts

@@ -0,0 +1,5 @@
+export function isHex(value: any) {
+  if (!value) return false
+  if (typeof value !== 'string') return false
+  return /^0x[0-9a-fA-F]*$/.test(value)
+}

package/src/utils/data/pad.bench.ts

@@ -0,0 +1,39 @@
+import { hexZeroPad, zeroPad } from 'ethers/lib/utils'
+import { hexZeroPad as hexZeroPad2, zeroPad as zeroPad2 } from 'essential-eth'
+
+import { bench, describe } from 'vitest'
+import Web3 from 'web3'
+
+import { padBytes, padHex } from './pad'
+
+describe('Pad Hex', () => {
+  bench('viem: `padHex`', () => {
+    padHex('0xa4e12a45')
+  })
+
+  bench('ethers: `hexZeroPad`', () => {
+    hexZeroPad('0xa4e12a45', 32)
+  })
+
+  bench('web3.js: `padLeft`', () => {
+    Web3.utils.padLeft('0xa4e12a45', 32)
+  })
+
+  bench('essential-eth: `hexZeroPad`', () => {
+    hexZeroPad2('0xa4e12a45', 32)
+  })
+})
+
+describe('Pad Bytes', () => {
+  bench('viem: `padBytes`', () => {
+    padBytes(new Uint8Array([1, 122, 51, 123]))
+  })
+
+  bench('ethers: `zeroPad`', () => {
+    zeroPad(new Uint8Array([1, 122, 51, 123]), 32)
+  })
+
+  bench('essential-eth: `zeroPad`', () => {
+    zeroPad2(new Uint8Array([1, 122, 51, 123]), 32)
+  })
+})