viem 0.0.1-alpha.24 → 0.0.1-alpha.26

package/src/clients/transports/fallback.test.ts

@@ -1,257 +0,0 @@
-import { assertType, describe, expect, test } from 'vitest'
-import { createHttpServer, localHttpUrl } from '../../_test'
-import { localhost } from '../../chains'
-import { createClient } from '../createClient'
-
-import { getBlockNumber } from '../../actions'
-import { fallback, FallbackTransport } from './fallback'
-import { http } from './http'
-
-test('default', () => {
-  const alchemy = http('https://alchemy.com/rpc')
-  const infura = http('https://infura.com/rpc')
-  const transport = fallback([alchemy, infura])
-
-  assertType<FallbackTransport>(transport)
-  assertType<'fallback'>(transport({}).config.type)
-
-  expect(transport({})).toMatchInlineSnapshot(`
-    {
-      "config": {
-        "key": "fallback",
-        "name": "Fallback",
-        "request": [Function],
-        "type": "fallback",
-      },
-      "value": {
-        "transports": [
-          {
-            "config": {
-              "key": "http",
-              "name": "HTTP JSON-RPC",
-              "request": [Function],
-              "type": "http",
-            },
-            "value": {
-              "url": "https://alchemy.com/rpc",
-            },
-          },
-          {
-            "config": {
-              "key": "http",
-              "name": "HTTP JSON-RPC",
-              "request": [Function],
-              "type": "http",
-            },
-            "value": {
-              "url": "https://infura.com/rpc",
-            },
-          },
-        ],
-      },
-    }
-  `)
-})
-
-describe('request', () => {
-  test('default', async () => {
-    const server = await createHttpServer((req, res) => {
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-      })
-      res.end(JSON.stringify({ result: '0x1' }))
-    })
-
-    const local = http(server.url)
-    const transport = fallback([local])({ chain: localhost })
-
-    expect(await transport.config.request({ method: 'eth_blockNumber' })).toBe(
-      '0x1',
-    )
-  })
-
-  test('error', async () => {
-    let count = 0
-    const server1 = await createHttpServer((req, res) => {
-      count++
-      res.writeHead(500)
-      res.end()
-    })
-    const server2 = await createHttpServer((req, res) => {
-      count++
-      res.writeHead(500)
-      res.end()
-    })
-    const server3 = await createHttpServer((req, res) => {
-      count++
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-      })
-      res.end(JSON.stringify({ result: '0x1' }))
-    })
-
-    let transport = fallback([http(server1.url), http(server3.url)])({
-      chain: localhost,
-    })
-    expect(await transport.config.request({ method: 'eth_blockNumber' })).toBe(
-      '0x1',
-    )
-
-    // ensure `retryCount` on transport is adhered
-    expect(count).toBe(4)
-
-    count = 0
-    transport = fallback([
-      http(server1.url),
-      http(server2.url),
-      http(server3.url),
-    ])({
-      chain: localhost,
-    })
-    expect(await transport.config.request({ method: 'eth_blockNumber' })).toBe(
-      '0x1',
-    )
-
-    // ensure `retryCount` on transport is adhered
-    expect(count).toBe(7)
-
-    count = 0
-    transport = fallback([http(server1.url), http(server2.url)])({
-      chain: localhost,
-    })
-    await expect(() =>
-      transport.config.request({ method: 'eth_blockNumber' }),
-    ).rejects.toThrowError()
-
-    // ensure `retryCount` on transport is adhered
-    expect(count).toBe(6)
-  })
-
-  test('error (rpc)', async () => {
-    let count = 0
-    const server1 = await createHttpServer((req, res) => {
-      count++
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-      })
-      res.end(JSON.stringify({ error: 'ngmi' }))
-    })
-    const server2 = await createHttpServer((req, res) => {
-      count++
-      res.writeHead(500)
-      res.end()
-    })
-    const server3 = await createHttpServer((req, res) => {
-      count++
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-      })
-      res.end(JSON.stringify({ result: '0x1' }))
-    })
-
-    let transport = fallback([
-      http(server1.url),
-      http(server2.url),
-      http(server3.url),
-    ])({
-      chain: localhost,
-    })
-    await expect(() =>
-      transport.config.request({ method: 'eth_blockNumber' }),
-    ).rejects.toThrowError()
-  })
-})
-
-describe('client', () => {
-  test('default', () => {
-    const alchemy = http('https://alchemy.com/rpc')
-    const infura = http('https://infura.com/rpc')
-    const transport = fallback([alchemy, infura])
-
-    const { uid, ...client } = createClient({
-      transport,
-    })
-
-    expect(client).toMatchInlineSnapshot(`
-      {
-        "chain": undefined,
-        "key": "base",
-        "name": "Base Client",
-        "pollingInterval": 4000,
-        "request": [Function],
-        "transport": {
-          "key": "fallback",
-          "name": "Fallback",
-          "request": [Function],
-          "transports": [
-            {
-              "config": {
-                "key": "http",
-                "name": "HTTP JSON-RPC",
-                "request": [Function],
-                "type": "http",
-              },
-              "value": {
-                "url": "https://alchemy.com/rpc",
-              },
-            },
-            {
-              "config": {
-                "key": "http",
-                "name": "HTTP JSON-RPC",
-                "request": [Function],
-                "type": "http",
-              },
-              "value": {
-                "url": "https://infura.com/rpc",
-              },
-            },
-          ],
-          "type": "fallback",
-        },
-        "type": "base",
-      }
-    `)
-  })
-
-  test('request', async () => {
-    const server = await createHttpServer((req, res) => {
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-      })
-      res.end(JSON.stringify({ result: '0x1' }))
-    })
-
-    const local = http(server.url)
-    const transport = fallback([local])
-    const client = createClient({ chain: localhost, transport })
-
-    expect(await getBlockNumber(client)).toBe(1n)
-  })
-
-  test('request (error)', async () => {
-    const server1 = await createHttpServer((req, res) => {
-      res.writeHead(500)
-      res.end()
-    })
-    const server2 = await createHttpServer((req, res) => {
-      res.writeHead(500)
-      res.end()
-    })
-    const server3 = await createHttpServer((req, res) => {
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-      })
-      res.end(JSON.stringify({ result: '0x1' }))
-    })
-
-    const transport = fallback([
-      http(server1.url),
-      http(server2.url),
-      http(server3.url),
-    ])
-    const client = createClient({ chain: localhost, transport })
-
-    expect(await getBlockNumber(client)).toBe(1n)
-  })
-})

package/src/clients/transports/fallback.ts

@@ -1,50 +0,0 @@
-import { HttpRequestError, RpcError } from '../../errors'
-import type { Transport, TransportConfig } from './createTransport'
-import { createTransport } from './createTransport'
-
-export type FallbackTransportConfig = {
-  /** The key of the Fallback transport. */
-  key?: TransportConfig['key']
-  /** The name of the Fallback transport. */
-  name?: TransportConfig['name']
-}
-
-export type FallbackTransport = Transport<
-  'fallback',
-  { transports: Transport[] }
->
-
-export function fallback(
-  transports: Transport[],
-  { key = 'fallback', name = 'Fallback' }: FallbackTransportConfig = {},
-): FallbackTransport {
-  return ({ chain }) =>
-    createTransport(
-      {
-        key,
-        name,
-        async request({ method, params }) {
-          const fetch = async (i: number = 0): Promise<any> => {
-            const transport = transports[i]({ chain })
-            try {
-              return await transport.config.request({
-                method,
-                params,
-              } as any)
-            } catch (err) {
-              if (!(err instanceof RpcError) && i < transports.length - 1)
-                return fetch(i + 1)
-              throw err
-            }
-          }
-          return fetch()
-        },
-        type: 'fallback',
-      },
-      {
-        transports: transports.map(
-          (fn) => fn({ chain }) as unknown as Transport,
-        ),
-      },
-    )
-}

package/src/clients/transports/http.test.ts

@@ -1,109 +0,0 @@
-import { assertType, describe, expect, test } from 'vitest'
-
-import { localhost } from '../../chains'
-
-import type { HttpTransport } from './http'
-import { http } from './http'
-
-test('default', () => {
-  const transport = http('https://mockapi.com/rpc')
-
-  assertType<HttpTransport>(transport)
-  assertType<'http'>(transport({}).config.type)
-
-  expect(transport({})).toMatchInlineSnapshot(`
-    {
-      "config": {
-        "key": "http",
-        "name": "HTTP JSON-RPC",
-        "request": [Function],
-        "type": "http",
-      },
-      "value": {
-        "url": "https://mockapi.com/rpc",
-      },
-    }
-  `)
-})
-
-describe('config', () => {
-  test('key', () => {
-    const transport = http('https://mockapi.com/rpc', {
-      key: 'mock',
-    })({})
-
-    expect(transport).toMatchInlineSnapshot(`
-      {
-        "config": {
-          "key": "mock",
-          "name": "HTTP JSON-RPC",
-          "request": [Function],
-          "type": "http",
-        },
-        "value": {
-          "url": "https://mockapi.com/rpc",
-        },
-      }
-    `)
-  })
-
-  test('name', () => {
-    const transport = http('https://mockapi.com/rpc', {
-      name: 'Mock Transport',
-    })({})
-
-    expect(transport).toMatchInlineSnapshot(`
-      {
-        "config": {
-          "key": "http",
-          "name": "Mock Transport",
-          "request": [Function],
-          "type": "http",
-        },
-        "value": {
-          "url": "https://mockapi.com/rpc",
-        },
-      }
-    `)
-  })
-
-  test('url', () => {
-    const transport = http('https://mockapi.com/rpc')({})
-
-    expect(transport).toMatchInlineSnapshot(`
-      {
-        "config": {
-          "key": "http",
-          "name": "HTTP JSON-RPC",
-          "request": [Function],
-          "type": "http",
-        },
-        "value": {
-          "url": "https://mockapi.com/rpc",
-        },
-      }
-    `)
-  })
-})
-
-test('request', async () => {
-  const transport = http(undefined, {
-    key: 'jsonRpc',
-    name: 'JSON RPC',
-  })({ chain: localhost })
-
-  expect(
-    await transport.config.request({ method: 'eth_blockNumber' }),
-  ).toBeDefined()
-})
-
-test('no url', () => {
-  expect(() => http()({})).toThrowErrorMatchingInlineSnapshot(
-    `
-    "No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.
-
-    Docs: https://viem.sh/docs/clients/intro
-    Version: viem@1.0.2"
-  `,
-  )
-})

package/src/clients/transports/http.ts

@@ -1,51 +0,0 @@
-import { UrlRequiredError } from '../../errors'
-import { rpc } from '../../utils/rpc'
-import type { Transport, TransportConfig } from './createTransport'
-import { createTransport } from './createTransport'
-
-export type HttpTransportConfig = {
-  /** The key of the HTTP transport. */
-  key?: TransportConfig['key']
-  /** The name of the HTTP transport. */
-  name?: TransportConfig['name']
-}
-
-export type HttpTransport = Transport<
-  'http',
-  {
-    url?: string
-  }
->
-
-/**
- * @description Creates a HTTP transport that connects to a JSON-RPC API.
- */
-export function http(
-  /** URL of the JSON-RPC API. Defaults to the chain's public RPC URL. */
-  url?: string,
-  { key = 'http', name = 'HTTP JSON-RPC' }: HttpTransportConfig = {},
-): HttpTransport {
-  return ({ chain }) => {
-    const url_ = url || chain?.rpcUrls.default.http[0]
-    if (!url_) throw new UrlRequiredError()
-    return createTransport(
-      {
-        key,
-        name,
-        async request({ method, params }) {
-          const { result } = await rpc.http(url_, {
-            body: {
-              method,
-              params,
-            },
-          })
-          return result
-        },
-        type: 'http',
-      },
-      {
-        url,
-      },
-    )
-  }
-}

package/src/clients/transports/index.test.ts

@@ -1,15 +0,0 @@
-import { expect, test } from 'vitest'
-
-import * as transports from './index'
-
-test('exports transports', () => {
-  expect(transports).toMatchInlineSnapshot(`
-    {
-      "createTransport": [Function],
-      "custom": [Function],
-      "fallback": [Function],
-      "http": [Function],
-      "webSocket": [Function],
-    }
-  `)
-})

package/src/clients/transports/index.ts

@@ -1,17 +0,0 @@
-export { createTransport } from './createTransport'
-export type { Transport, TransportConfig } from './createTransport'
-
-export { custom } from './custom'
-export type {
-  CustomTransport,
-  CustomTransportConfig,
-} from './custom'
-
-export { fallback } from './fallback'
-export type { FallbackTransport, FallbackTransportConfig } from './fallback'
-
-export { http } from './http'
-export type { HttpTransport, HttpTransportConfig } from './http'
-
-export { webSocket } from './webSocket'
-export type { WebSocketTransport, WebSocketTransportConfig } from './webSocket'

package/src/clients/transports/webSocket.test.ts

@@ -1,163 +0,0 @@
-import { assertType, describe, expect, test } from 'vitest'
-
-import { localWsUrl } from '../../_test'
-import { localhost } from '../../chains'
-import { wait } from '../../utils/wait'
-import type { WebSocketTransport } from './webSocket'
-import { webSocket } from './webSocket'
-
-test('default', () => {
-  const transport = webSocket(localWsUrl)
-
-  assertType<WebSocketTransport>(transport)
-  assertType<'webSocket'>(transport({}).config.type)
-
-  expect(transport).toMatchInlineSnapshot('[Function]')
-})
-
-describe('config', () => {
-  test('key', () => {
-    const transport = webSocket(localWsUrl, {
-      key: 'mock',
-    })
-
-    expect(transport({})).toMatchInlineSnapshot(`
-      {
-        "config": {
-          "key": "mock",
-          "name": "WebSocket JSON-RPC",
-          "request": [Function],
-          "type": "webSocket",
-        },
-        "value": {
-          "getSocket": [Function],
-          "subscribe": [Function],
-        },
-      }
-    `)
-  })
-
-  test('name', () => {
-    const transport = webSocket(localWsUrl, {
-      name: 'Mock Transport',
-    })
-
-    expect(transport({})).toMatchInlineSnapshot(`
-      {
-        "config": {
-          "key": "webSocket",
-          "name": "Mock Transport",
-          "request": [Function],
-          "type": "webSocket",
-        },
-        "value": {
-          "getSocket": [Function],
-          "subscribe": [Function],
-        },
-      }
-    `)
-  })
-
-  test('url', () => {
-    const transport = webSocket('https://mockapi.com/rpc')
-
-    expect(transport({})).toMatchInlineSnapshot(`
-      {
-        "config": {
-          "key": "webSocket",
-          "name": "WebSocket JSON-RPC",
-          "request": [Function],
-          "type": "webSocket",
-        },
-        "value": {
-          "getSocket": [Function],
-          "subscribe": [Function],
-        },
-      }
-    `)
-  })
-})
-
-test('getSocket', async () => {
-  const transport = webSocket(localWsUrl)
-  const socket = await transport({}).value?.getSocket()
-  expect(socket).toBeDefined()
-  expect(socket?.readyState).toBe(WebSocket.OPEN)
-})
-
-test('request', async () => {
-  const transport = webSocket(undefined, {
-    key: 'jsonRpc',
-    name: 'JSON RPC',
-  })
-
-  expect(
-    await transport({
-      chain: {
-        ...localhost,
-        rpcUrls: {
-          public: { http: [localWsUrl], webSocket: [localWsUrl] },
-          default: { http: [localWsUrl], webSocket: [localWsUrl] },
-        },
-      },
-    }).config.request({
-      method: 'eth_blockNumber',
-    }),
-  ).toBeDefined()
-})
-
-test('subscribe', async () => {
-  const transport = webSocket(localWsUrl, {
-    key: 'jsonRpc',
-    name: 'JSON RPC',
-  })({})
-  if (!transport.value) return
-
-  let blocks: any[] = []
-  const { subscriptionId, unsubscribe } = await transport.value.subscribe({
-    params: ['newHeads'],
-    onData: (data) => blocks.push(data),
-  })
-
-  // Make sure we are subscribed.
-  expect(subscriptionId).toBeDefined()
-
-  // Make sure we are receiving blocks.
-  await wait(2000)
-  expect(blocks.length).toBe(2)
-
-  // Make sure we unsubscribe.
-  const { result } = await unsubscribe()
-  expect(result).toBeDefined()
-
-  // Make sure we are no longer receiving blocks.
-  await wait(2000)
-  expect(blocks.length).toBe(2)
-})
-
-test('throws on bogus subscription', async () => {
-  const transport = webSocket(localWsUrl, {
-    key: 'jsonRpc',
-    name: 'JSON RPC',
-  })
-
-  let errors: any[] = []
-  await expect(() =>
-    transport({}).value?.subscribe({
-      // @ts-expect-error - testing
-      params: ['lol'],
-      onData: () => null,
-      onError: (err) => errors.push(err),
-    }),
-  ).rejects.toThrowError()
-  expect(errors.length).toBeGreaterThan(0)
-})
-
-test('no url', () => {
-  expect(() => webSocket()({})).toThrowErrorMatchingInlineSnapshot(`
-    "No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.
-
-    Docs: https://viem.sh/docs/clients/intro
-    Version: viem@1.0.2"
-  `)
-})