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

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

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

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

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