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

package/src/errors/request.test.ts

@@ -0,0 +1,330 @@
+import { expect, test } from 'vitest'
+import {
+  InternalRpcError,
+  InvalidInputRpcError,
+  InvalidParamsRpcError,
+  InvalidRequestRpcError,
+  JsonRpcVersionUnsupportedError,
+  LimitExceededRpcError,
+  MethodNotFoundRpcError,
+  MethodNotSupportedRpcError,
+  ParseRpcError,
+  RequestError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  RpcRequestError,
+  TransactionRejectedRpcError,
+  UnknownRpcError,
+} from './request'
+import { RpcError } from './rpc'
+
+test('RequestError', () => {
+  expect(
+    new RequestError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: { code: 1337, message: 'error details' },
+      }),
+      {
+        shortMessage: 'An internal error was received.',
+      },
+    ),
+  ).toMatchInlineSnapshot(`
+    [RpcError: An internal error was received.
+
+    Details: error details
+    Version: viem@1.0.2]
+  `)
+})
+
+test('RpcRequestError', () => {
+  expect(
+    new RpcRequestError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: { code: 1337, message: 'error details' },
+      }),
+      { shortMessage: 'An internal error was received.' },
+    ),
+  ).toMatchInlineSnapshot(`
+    [RpcError: An internal error was received.
+
+    Details: error details
+    Version: viem@1.0.2]
+  `)
+})
+
+test('RpcRequestError', () => {
+  expect(
+    new RpcRequestError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: { code: 1337, message: 'error details' },
+      }),
+      {
+        shortMessage: 'An internal error was received.',
+        docsPath: '/lol',
+      },
+    ),
+  ).toMatchInlineSnapshot(`
+    [RpcError: An internal error was received.
+
+    Docs: https://viem.sh/lol
+    Details: error details
+    Version: viem@1.0.2]
+  `)
+})
+
+test('ParseRpcError', () => {
+  expect(
+    new ParseRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32700,
+          message: 'message',
+        },
+      }),
+    ),
+  ).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('InvalidRequestRpcError', () => {
+  expect(
+    new InvalidRequestRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32600,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [InvalidRequestRpcError: JSON is not a valid request object.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('MethodNotFoundRpcError', () => {
+  expect(
+    new MethodNotFoundRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32601,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [MethodNotFoundRpcError: The method does not exist / is not available.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('InvalidParamsRpcError', () => {
+  expect(
+    new InvalidParamsRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32602,
+          message: 'message',
+        },
+      }),
+    ),
+  ).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', () => {
+  expect(
+    new InternalRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32603,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [InternalRpcError: An internal error was received.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('InvalidInputRpcError', () => {
+  expect(
+    new InvalidInputRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32000,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [InvalidInputRpcError: Missing or invalid parameters.
+    Double check you have provided the correct parameters.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('ResourceNotFoundRpcError', () => {
+  expect(
+    new ResourceNotFoundRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32001,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [ResourceNotFoundRpcError: Requested resource not found.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('ResourceUnavailableRpcError', () => {
+  expect(
+    new ResourceUnavailableRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32002,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [ResourceUnavailableRpcError: Requested resource not available.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('TransactionRejectedRpcError', () => {
+  expect(
+    new TransactionRejectedRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32003,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [TransactionRejectedRpcError: Transaction creation failed.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('MethodNotSupportedRpcError', () => {
+  expect(
+    new MethodNotSupportedRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32004,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [MethodNotSupportedRpcError: Method is not implemented.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('LimitExceededRpcError', () => {
+  expect(
+    new LimitExceededRpcError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32005,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [LimitExceededRpcError: Request exceeds defined limit.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('JsonRpcVersionUnsupportedError', () => {
+  expect(
+    new JsonRpcVersionUnsupportedError(
+      new RpcError({
+        body: { foo: 'bar' },
+        url: 'https://viem.sh',
+        error: {
+          code: -32006,
+          message: 'message',
+        },
+      }),
+    ),
+  ).toMatchInlineSnapshot(`
+    [JsonRpcVersionUnsupportedError: Version of JSON-RPC protocol is not supported.
+
+    Details: message
+    Version: viem@1.0.2]
+  `)
+})
+
+test('UnknownRpcError', async () => {
+  expect(new UnknownRpcError(new Error('oh no'))).toMatchInlineSnapshot(`
+    [UnknownRpcError: An unknown RPC error occurred.
+
+    Details: oh no
+    Version: viem@1.0.2]
+  `)
+})

package/src/errors/request.ts

@@ -0,0 +1,163 @@
+import { BaseError } from './base'
+import { RpcError } from './rpc'
+
+export class RequestError extends BaseError {
+  constructor(
+    err: Error,
+    { docsPath, shortMessage }: { docsPath?: string; shortMessage: string },
+  ) {
+    super(shortMessage, {
+      cause: err,
+      docsPath,
+    })
+    this.name = err.name
+  }
+}
+
+export class RpcRequestError extends RequestError {
+  code: number
+
+  constructor(
+    err: RpcError,
+    { docsPath, shortMessage }: { docsPath?: string; shortMessage: string },
+  ) {
+    super(err, { docsPath, shortMessage })
+    this.code = err.code
+    this.name = err.name
+  }
+}
+
+export class ParseRpcError extends RpcRequestError {
+  name = 'ParseRpcError'
+  code = -32700
+
+  constructor(err: RpcError) {
+    super(err, {
+      shortMessage:
+        'Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.',
+    })
+  }
+}
+
+export class InvalidRequestRpcError extends RpcRequestError {
+  name = 'InvalidRequestRpcError'
+  code = -32600
+
+  constructor(err: RpcError) {
+    super(err, { shortMessage: 'JSON is not a valid request object.' })
+  }
+}
+
+export class MethodNotFoundRpcError extends RpcRequestError {
+  name = 'MethodNotFoundRpcError'
+  code = -32601
+
+  constructor(err: RpcError) {
+    super(err, {
+      shortMessage: 'The method does not exist / is not available.',
+    })
+  }
+}
+
+export class InvalidParamsRpcError extends RpcRequestError {
+  name = 'InvalidParamsRpcError'
+  code = -32602
+
+  constructor(err: RpcError) {
+    super(err, {
+      shortMessage: [
+        'Invalid parameters were provided to the RPC method.',
+        'Double check you have provided the correct parameters.',
+      ].join('\n'),
+    })
+  }
+}
+
+export class InternalRpcError extends RpcRequestError {
+  name = 'InternalRpcError'
+  code = -32603
+
+  constructor(err: RpcError) {
+    super(err, { shortMessage: 'An internal error was received.' })
+  }
+}
+
+export class InvalidInputRpcError extends RpcRequestError {
+  name = 'InvalidInputRpcError'
+  code = -32000
+
+  constructor(err: RpcError) {
+    super(err, {
+      shortMessage: [
+        'Missing or invalid parameters.',
+        'Double check you have provided the correct parameters.',
+      ].join('\n'),
+    })
+  }
+}
+
+export class ResourceNotFoundRpcError extends RpcRequestError {
+  name = 'ResourceNotFoundRpcError'
+  code = -32001
+
+  constructor(err: RpcError) {
+    super(err, { shortMessage: 'Requested resource not found.' })
+  }
+}
+
+export class ResourceUnavailableRpcError extends RpcRequestError {
+  name = 'ResourceUnavailableRpcError'
+  code = -32002
+
+  constructor(err: RpcError) {
+    super(err, { shortMessage: 'Requested resource not available.' })
+  }
+}
+
+export class TransactionRejectedRpcError extends RpcRequestError {
+  name = 'TransactionRejectedRpcError'
+  code = -32003
+
+  constructor(err: RpcError) {
+    super(err, { shortMessage: 'Transaction creation failed.' })
+  }
+}
+
+export class MethodNotSupportedRpcError extends RpcRequestError {
+  name = 'MethodNotSupportedRpcError'
+  code = -32004
+
+  constructor(err: RpcError) {
+    super(err, { shortMessage: 'Method is not implemented.' })
+  }
+}
+
+export class LimitExceededRpcError extends RpcRequestError {
+  name = 'LimitExceededRpcError'
+  code = -32005
+
+  constructor(err: RpcError) {
+    super(err, { shortMessage: 'Request exceeds defined limit.' })
+  }
+}
+
+export class JsonRpcVersionUnsupportedError extends RpcRequestError {
+  name = 'JsonRpcVersionUnsupportedError'
+  code = -32006
+
+  constructor(err: RpcError) {
+    super(err, {
+      shortMessage: 'Version of JSON-RPC protocol is not supported.',
+    })
+  }
+}
+
+export class UnknownRpcError extends RequestError {
+  name = 'UnknownRpcError'
+
+  constructor(err: Error) {
+    super(err, {
+      shortMessage: 'An unknown RPC error occurred.',
+    })
+  }
+}

package/src/errors/rpc.test.ts

@@ -0,0 +1,87 @@
+import { expect, test } from 'vitest'
+import { initialBlockNumber } from '../_test'
+import { numberToHex } from '../utils'
+import {
+  HttpRequestError,
+  RpcError,
+  TimeoutError,
+  WebSocketRequestError,
+} from './rpc'
+
+test('RpcError', () => {
+  const err = new RpcError({
+    body: { foo: 'bar' },
+    error: { code: 420, message: 'Error' },
+    url: 'https://lol.com',
+  })
+  expect(err).toMatchInlineSnapshot(`
+    [RpcError: RPC Request failed.
+
+    URL: https://lol.com
+    Request body: {"foo":"bar"}
+
+    Details: Error
+    Version: viem@1.0.2]
+  `)
+})
+
+test('HttpRequestError', () => {
+  const err = new HttpRequestError({
+    url: 'https://eth-mainnet.g.alchemy.com/v2/_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC',
+    body: {
+      method: 'eth_getBlockByNumber',
+      params: [numberToHex(initialBlockNumber), false],
+    },
+    status: 500,
+    details: 'Some error',
+  })
+  expect(err).toMatchInlineSnapshot(`
+    [HttpRequestError: HTTP request failed.
+
+    Status: 500
+    URL: https://eth-mainnet.g.alchemy.com/v2/_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC
+    Request body: {"method":"eth_getBlockByNumber","params":["0xf86cc2",false]}
+
+    Details: Some error
+    Version: viem@1.0.2]
+  `)
+})
+
+test('WebSocketRequestError', () => {
+  const err = new WebSocketRequestError({
+    url: 'ws://eth-mainnet.g.alchemy.com/v2/_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC',
+    body: {
+      method: 'eth_getBlockByNumber',
+      params: [numberToHex(initialBlockNumber), false],
+    },
+    details: 'Some error',
+  })
+  expect(err).toMatchInlineSnapshot(`
+    [WebSocketRequestError: WebSocket request failed.
+
+    URL: ws://eth-mainnet.g.alchemy.com/v2/_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC
+    Request body: {"method":"eth_getBlockByNumber","params":["0xf86cc2",false]}
+
+    Details: Some error
+    Version: viem@1.0.2]
+  `)
+})
+
+test('TimeoutError', () => {
+  const err = new TimeoutError({
+    url: 'https://eth-mainnet.g.alchemy.com/v2/_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC',
+    body: {
+      method: 'eth_getBlockByNumber',
+      params: [numberToHex(initialBlockNumber), false],
+    },
+  })
+  expect(err).toMatchInlineSnapshot(`
+    [TimeoutError: The request took too long to respond.
+
+    URL: https://eth-mainnet.g.alchemy.com/v2/_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC
+    Request body: {"method":"eth_getBlockByNumber","params":["0xf86cc2",false]}
+
+    Details: The request timed out.
+    Version: viem@1.0.2]
+  `)
+})

package/src/errors/rpc.ts

@@ -0,0 +1,113 @@
+import { stringify } from '../utils'
+import { BaseError } from './base'
+
+export class HttpRequestError extends BaseError {
+  name = 'HttpRequestError'
+  status
+
+  constructor({
+    body,
+    details,
+    status,
+    url,
+  }: {
+    body: { [key: string]: unknown }
+    details: string
+    status: number
+    url: string
+  }) {
+    super(
+      [
+        'HTTP request failed.',
+        '',
+        `Status: ${status}`,
+        `URL: ${url}`,
+        `Request body: ${stringify(body)}`,
+      ].join('\n'),
+      {
+        details,
+      },
+    )
+    this.status = status
+  }
+}
+
+export class WebSocketRequestError extends BaseError {
+  name = 'WebSocketRequestError'
+
+  constructor({
+    body,
+    details,
+    url,
+  }: {
+    body: { [key: string]: unknown }
+    details: string
+    url: string
+  }) {
+    super(
+      [
+        'WebSocket request failed.',
+        '',
+        `URL: ${url}`,
+        `Request body: ${stringify(body)}`,
+      ].join('\n'),
+      {
+        details,
+      },
+    )
+  }
+}
+
+export class RpcError extends BaseError {
+  code: number
+
+  name = 'RpcError'
+
+  constructor({
+    body,
+    error,
+    url,
+  }: {
+    body: { [key: string]: unknown }
+    error: { code: number; message: string }
+    url: string
+  }) {
+    super(
+      [
+        'RPC Request failed.',
+        '',
+        `URL: ${url}`,
+        `Request body: ${stringify(body)}`,
+      ].join('\n'),
+      {
+        cause: error as any,
+        details: error.message,
+      },
+    )
+    this.code = error.code
+  }
+}
+
+export class TimeoutError extends BaseError {
+  name = 'TimeoutError'
+
+  constructor({
+    body,
+    url,
+  }: {
+    body: { [key: string]: unknown }
+    url: string
+  }) {
+    super(
+      [
+        'The request took too long to respond.',
+        '',
+        `URL: ${url}`,
+        `Request body: ${stringify(body)}`,
+      ].join('\n'),
+      {
+        details: 'The request timed out.',
+      },
+    )
+  }
+}