viem 0.0.1-cjs.10 → 0.0.1-sushi.26

package/src/utils/buildRequest.test.ts

@@ -0,0 +1,428 @@
+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 () => {
+  await expect(() =>
+    buildRequest(() => Promise.reject(new Error('wat')))(),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "An unknown RPC error occurred.
+
+    Details: wat
+    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]
+    `)
+  }
+})
+
+test('retries: BaseError (should not retry)', async () => {
+  let retryCount = -1
+  await expect(() =>
+    buildRequest(() => {
+      retryCount++
+      return Promise.reject(new BaseError('foo', { details: 'bar' }))
+    })(),
+  ).rejects.toThrowError()
+  expect(retryCount).toBe(0)
+})
+
+test('retries: InternalRpcError', async () => {
+  let retryCount = -1
+  await expect(() =>
+    buildRequest(() => {
+      retryCount++
+      return Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32603, message: 'message' },
+        }),
+      )
+    })(),
+  ).rejects.toThrowError()
+  expect(retryCount).toBe(3)
+})
+
+test('retries: InvalidInputRpcError', async () => {
+  let retryCount = -1
+  await expect(() =>
+    buildRequest(() => {
+      retryCount++
+      return Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32000, message: 'message' },
+        }),
+      )
+    })(),
+  ).rejects.toThrowError()
+  expect(retryCount).toBe(3)
+})
+
+test('retries: LimitExceededRpcError', async () => {
+  let retryCount = -1
+  await expect(() =>
+    buildRequest(() => {
+      retryCount++
+      return Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32005, message: 'message' },
+        }),
+      )
+    })(),
+  ).rejects.toThrowError()
+  expect(retryCount).toBe(3)
+})
+
+test('retries: UnknownRpcError', async () => {
+  let retryCount = -1
+  await expect(() =>
+    buildRequest(() => {
+      retryCount++
+      return Promise.reject(new Error('wat'))
+    })(),
+  ).rejects.toThrowError()
+  expect(retryCount).toBe(3)
+})

package/src/utils/buildRequest.ts

@@ -0,0 +1,72 @@
+import {
+  BaseError,
+  InternalRpcError,
+  InvalidInputRpcError,
+  InvalidParamsRpcError,
+  InvalidRequestRpcError,
+  JsonRpcVersionUnsupportedError,
+  LimitExceededRpcError,
+  MethodNotFoundRpcError,
+  MethodNotSupportedRpcError,
+  ParseRpcError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  RpcError,
+  TransactionRejectedRpcError,
+  UnknownRpcError,
+} from '../errors'
+import { withRetry } from './promise'
+
+export const isNonDeterministicError = (error: Error) => {
+  if (error instanceof UnknownRpcError) return true
+  if ('code' in error)
+    return (
+      error.code === -32603 || error.code === -32000 || error.code === -32005
+    )
+  return false
+}
+
+export function buildRequest<TRequest extends (args: any) => Promise<any>>(
+  request: TRequest,
+  {
+    retryDelay = 150,
+    retryCount = 3,
+  }: {
+    // The base delay (in ms) between retries.
+    retryDelay?: number
+    // The max number of times to retry.
+    retryCount?: number
+  } = {},
+) {
+  return (async (args: any) =>
+    withRetry(
+      async () => {
+        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)
+        }
+      },
+      {
+        delay: ({ count }) => ~~(1 << count) * retryDelay,
+        retryCount,
+        shouldRetryOnError: ({ error }) => isNonDeterministicError(error),
+      },
+    )) as TRequest
+}

package/src/utils/chain.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from 'vitest'
+import { celo } from '../chains'
+import { defineChain } from './chain'
+
+describe('defineChain', () => {
+  test('default', () => {
+    expect(
+      defineChain({
+        id: 42220,
+        name: 'Celo',
+        network: 'celo',
+        nativeCurrency: { name: 'Celo', symbol: 'CELO', decimals: 18 },
+        rpcUrls: {
+          public: { http: ['https://rpc.ankr.com/celo'] },
+          default: { http: ['https://rpc.ankr.com/celo'] },
+        },
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "id": 42220,
+        "name": "Celo",
+        "nativeCurrency": {
+          "decimals": 18,
+          "name": "Celo",
+          "symbol": "CELO",
+        },
+        "network": "celo",
+        "rpcUrls": {
+          "default": {
+            "http": [
+              "https://rpc.ankr.com/celo",
+            ],
+          },
+          "public": {
+            "http": [
+              "https://rpc.ankr.com/celo",
+            ],
+          },
+        },
+      }
+    `)
+  })
+})

package/src/utils/chain.ts

@@ -0,0 +1,8 @@
+import { Chain, Formatters } from '../types'
+
+export function defineChain<
+  TFormatters extends Formatters = Formatters,
+  TChain extends Chain<TFormatters> = Chain<TFormatters>,
+>(chain: TChain) {
+  return chain
+}

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
+}