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

package/src/utils/buildRequest.test.ts

@@ -0,0 +1,365 @@
+import { expect, test } from 'vitest'
+
+import { BaseError, RpcError, TimeoutError } from '../errors'
+import { buildRequest } from './buildRequest'
+
+test('valid request', async () => {
+  expect(
+    await buildRequest((args) => Promise.resolve({ ok: true, ...args }))({
+      foo: 'bar',
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "foo": "bar",
+      "ok": true,
+    }
+  `)
+})
+
+test('BaseError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(new BaseError('foo', { details: 'bar' })),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [ViemError: foo
+
+      Details: bar
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('ParseRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32700, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [ParseRpcError: Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('InvalidRpcRequestError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32600, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [InvalidRequestRpcError: JSON is not a valid request object.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('MethodNotFoundRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32601, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [MethodNotFoundRpcError: The method does not exist / is not available.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('InvalidParamsRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32602, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [InvalidParamsRpcError: Invalid parameters were provided to the RPC method.
+      Double check you have provided the correct parameters.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('InternalRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32603, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [InternalRpcError: An internal error was received.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('InvalidInputRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32000, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [InvalidInputRpcError: Missing or invalid parameters.
+      Double check you have provided the correct parameters.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('ResourceNotFoundRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32001, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [ResourceNotFoundRpcError: Requested resource not found.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('ResourceUnavailableRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32002, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [ResourceUnavailableRpcError: Requested resource not available.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('TransactionRejectedRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32003, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [TransactionRejectedRpcError: Transaction creation failed.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('MethodNotSupportedRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32004, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [MethodNotSupportedRpcError: Method is not implemented.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('LimitExceededRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32005, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [LimitExceededRpcError: Request exceeds defined limit.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('JsonRpcVersionUnsupportedError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32006, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [JsonRpcVersionUnsupportedError: Version of JSON-RPC protocol is not supported.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('InvalidParamsRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32602, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [InvalidParamsRpcError: Invalid parameters were provided to the RPC method.
+      Double check you have provided the correct parameters.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('Error', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: 69, message: 'message' },
+        }),
+      ),
+    )
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [UnknownRpcError: An unknown RPC error occurred.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('TimeoutError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new TimeoutError({
+          body: { foo: 'bar' },
+          url: 'http://localhost:8000',
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [TimeoutError: The request took too long to respond.
+
+      URL: http://localhost:8000
+      Request body: {"foo":"bar"}
+
+      Details: The request timed out.
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('Unknown error', async () => {
+  try {
+    await buildRequest(() => Promise.reject(new Error('wagmi')))()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [UnknownRpcError: An unknown RPC error occurred.
+
+      Details: wagmi
+      Version: viem@1.0.2]
+    `)
+  }
+})

package/src/utils/buildRequest.ts

@@ -0,0 +1,45 @@
+import {
+  BaseError,
+  InternalRpcError,
+  InvalidInputRpcError,
+  InvalidParamsRpcError,
+  InvalidRequestRpcError,
+  JsonRpcVersionUnsupportedError,
+  LimitExceededRpcError,
+  MethodNotFoundRpcError,
+  MethodNotSupportedRpcError,
+  ParseRpcError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  RpcError,
+  TransactionRejectedRpcError,
+  UnknownRpcError,
+} from '../errors'
+
+export function buildRequest<TRequest extends (args: any) => Promise<any>>(
+  request: TRequest,
+) {
+  return (async (args: any) => {
+    try {
+      return await request(args)
+    } catch (err_) {
+      let err = err_ as unknown as RpcError
+      if (err.code === -32700) throw new ParseRpcError(err)
+      if (err.code === -32600) throw new InvalidRequestRpcError(err)
+      if (err.code === -32601) throw new MethodNotFoundRpcError(err)
+      if (err.code === -32602) throw new InvalidParamsRpcError(err)
+      if (err.code === -32603) throw new InternalRpcError(err)
+      if (err.code === -32000) throw new InvalidInputRpcError(err)
+      if (err.code === -32001) throw new ResourceNotFoundRpcError(err)
+      if (err.code === -32002) throw new ResourceUnavailableRpcError(err)
+      if (err.code === -32003) throw new TransactionRejectedRpcError(err)
+      if (err.code === -32004) throw new MethodNotSupportedRpcError(err)
+      if (err.code === -32005) throw new LimitExceededRpcError(err)
+      if (err.code === -32006) throw new JsonRpcVersionUnsupportedError(err)
+      // TODO: 4001 - user rejected
+      // TODO: 4902 - switch chain error
+      if (err_ instanceof BaseError) throw err_
+      throw new UnknownRpcError(err as Error)
+    }
+  }) as TRequest
+}

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,70 @@
+import { Abi } from 'abitype'
+import {
+  AbiDecodingZeroDataError,
+  ContractMethodExecutionError,
+  ContractMethodZeroDataError,
+} from '../../errors'
+import { Address } from '../../types'
+import {
+  formatAbiItemWithArgs,
+  formatAbiItemWithParams,
+  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
+    ? formatAbiItemWithParams(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
+}