viem 0.0.1-alpha.14 → 0.0.1-alpha.16

package/src/clients/transports/custom.ts

@@ -0,0 +1,34 @@
+import type {
+  BaseRpcRequests,
+  Transport,
+  TransportConfig,
+} from './createTransport'
+import { createTransport } from './createTransport'
+
+type EthereumProvider = { request: BaseRpcRequests['request'] }
+
+export type CustomTransportConfig = {
+  /** The key of the transport. */
+  key?: TransportConfig['key']
+  /** The name of the transport. */
+  name?: TransportConfig['name']
+}
+
+export type CustomTransport = Transport<'custom', EthereumProvider['request']>
+
+/**
+ * @description Creates a custom transport given an EIP-1193 compliant `request` attribute.
+ */
+export function custom<TProvider extends EthereumProvider>(
+  /** An Ethereum provider with an EIP-1193 "request" attribute. */
+  provider: TProvider,
+  { key = 'custom', name = 'Custom Provider' }: CustomTransportConfig = {},
+): CustomTransport {
+  return () =>
+    createTransport({
+      key,
+      name,
+      request: provider.request.bind(provider),
+      type: 'custom',
+    })
+}

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

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

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

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

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

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

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

@@ -0,0 +1,164 @@
+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"
+  `)
+})