viem 0.0.1-sushi.26 → 0.1.0

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

@@ -1,393 +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(5)
-
-    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(9)
-
-    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(8)
-  })
-
-  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()
-
-    expect(count).toBe(1)
-  })
-
-  test('error (rpc - non deterministic)', async () => {
-    let count = 0
-    const server1 = await createHttpServer((req, res) => {
-      count++
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-      })
-      res.end(JSON.stringify({ error: { code: -32000, message: 'sad times' } }))
-    })
-    const server2 = 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)])({
-      chain: localhost,
-    })
-    expect(
-      await transport.config.request({ method: 'eth_blockNumber' }),
-    ).toMatchInlineSnapshot('"0x1"')
-
-    expect(count).toBe(2)
-  })
-
-  test('all 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()
-    })
-
-    let 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(8)
-  })
-
-  test.skip('all error (rpc - non deterministic)', async () => {
-    let count = 0
-    const server1 = await createHttpServer((req, res) => {
-      count++
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-      })
-      res.end(JSON.stringify({ error: { code: -32000, message: 'sad times' } }))
-    })
-    const server2 = await createHttpServer((req, res) => {
-      count++
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-      })
-      res.end(JSON.stringify({ error: { code: -32000, message: 'sad times' } }))
-    })
-
-    let transport = fallback([http(server1.url), http(server2.url)])({
-      chain: localhost,
-    })
-    await expect(() =>
-      transport.config.request({ method: 'eth_blockNumber' }),
-    ).rejects.toThrowError()
-
-    expect(count).toBe(8)
-  })
-})
-
-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)
-  })
-
-  test('error (non deterministic)', async () => {
-    let count = 0
-    const server1 = await createHttpServer((req, res) => {
-      count++
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-      })
-      res.end(JSON.stringify({ error: { code: -32000, message: 'sad times' } }))
-    })
-    const server2 = 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)])
-    const client = createClient({ chain: localhost, transport })
-
-    expect(await getBlockNumber(client)).toBe(1n)
-    expect(count).toBe(2)
-  })
-
-  test('all error (non deterministic)', async () => {
-    let count = 0
-    const server1 = await createHttpServer((req, res) => {
-      count++
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-      })
-      res.end(JSON.stringify({ error: { code: -32000, message: 'sad times' } }))
-    })
-    const server2 = await createHttpServer((req, res) => {
-      count++
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-      })
-      res.end(JSON.stringify({ error: { code: -32000, message: 'sad times' } }))
-    })
-
-    let transport = fallback([http(server1.url), http(server2.url)])
-    const client = createClient({ chain: localhost, transport })
-
-    await expect(
-      getBlockNumber(client),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "Missing or invalid parameters.
-      Double check you have provided the correct parameters.
-
-      Details: sad times
-      Version: viem@1.0.2"
-    `)
-    expect(count).toBe(8)
-  })
-})

package/src/clients/transports/fallback.ts

@@ -1,58 +0,0 @@
-import { RpcError } from '../../errors'
-import { isNonDeterministicError } from '../../utils/buildRequest'
-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 the error is deterministic, we don't need to fall back.
-              // So throw the error.
-              if (err instanceof RpcError && !isNonDeterministicError(err))
-                throw err
-
-              // If we've reached the end of the fallbacks, throw the error.
-              if (i === transports.length - 1) throw err
-
-              // Otherwise, try the next fallback.
-              return fetch(i + 1)
-            }
-          }
-          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'