viem 0.0.1-sushi.26 → 0.1.0

package/src/utils/buildRequest.test.ts

@@ -1,428 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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
-}