chore: add chain url avaliable check (#1309)

* feat: add chain url avaliable check

* ci: add check action

* chore: rename check file

* fix: getSocket withTimeout

* refactor: use bun test

* polish

* lint

---------

Co-authored-by: moxey.eth <jakemoxey@gmail.com>

Author: izayl

.github/workflows/chaincheck.yml

@@ -0,0 +1,25 @@
+name: Check chains
+on:
+  workflow_dispatch:
+  workflow_call:
+  pull_request:
+    paths:
+      - src/chains/**
+
+jobs:
+  chaincheck:
+    name: Check chains
+    needs: build
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    timeout-minutes: 10
+
+    steps:
+      - name: Clone repository
+        uses: actions/checkout@v4
+
+      - name: Install dependencies
+        uses: ./.github/actions/install-dependencies
+
+      - name: Check chain
+        run: bun run chaincheck

package.json

@@ -9,6 +9,7 @@
     "build:cjs": "tsc --project ./tsconfig.build.json --module commonjs --outDir ./src/_cjs --removeComments --verbatimModuleSyntax false && printf '{\"type\":\"commonjs\"}' > ./src/_cjs/package.json",
     "build:esm": "tsc --project ./tsconfig.build.json --module es2015 --outDir ./src/_esm && printf '{\"type\": \"module\",\"sideEffects\":false}' > ./src/_esm/package.json",
     "build:types": "tsc --project ./tsconfig.build.json --module esnext --declarationDir ./src/_types --emitDeclarationOnly --declaration --declarationMap",
+    "chaincheck": "bun test test/chains/check.test.ts",
     "changeset": "changeset",
     "changeset:release": "bun run build && bun run prepublishOnly && changeset publish",
     "changeset:version": "changeset version && bun scripts/updateVersion.ts && bun install --lockfile-only",

src/utils/promise/withTimeout.ts

@@ -5,12 +5,12 @@ export type WithTimeoutErrorType = ErrorType
 export function withTimeout<TData>(
   fn: ({ signal }: { signal?: AbortController['signal'] }) => Promise<TData>,
   {
-    errorInstance,
+    errorInstance = new Error('timed out'),
     timeout,
     signal,
   }: {
     // The error instance to throw when the timeout is reached.
-    errorInstance: Error
+    errorInstance?: Error
     // The timeout (in ms).
     timeout: number
     // Whether or not the timeout should use an abort signal.

test/chains/check.test.ts

@@ -0,0 +1,91 @@
+import { expect, test } from 'bun:test'
+
+import * as chains from '~viem/chains/index.js'
+import type { Chain } from '~viem/types/chain.js'
+import { withTimeout } from '~viem/utils/promise/withTimeout.js'
+import { getSocket, rpc } from '~viem/utils/rpc.js'
+
+const defaultTimeout = 10_000
+
+const chains_ = Object.values(chains) as readonly Chain[]
+chains_.forEach((chain) => {
+  const httpRpcUrls = chain.rpcUrls.default.http
+  if (httpRpcUrls)
+    test(
+      `${chain.name}: check http urls`,
+      async () => {
+        await assertHttpRpcUrls(chain.id, httpRpcUrls)
+      },
+      { timeout: defaultTimeout },
+    )
+
+  const webSocketRpcUrls = chain.rpcUrls.default.webSocket
+  if (webSocketRpcUrls)
+    test(
+      `${chain.name}: check web socket urls`,
+      async () => {
+        await assertWebSocketRpcUrls(chain.id, webSocketRpcUrls)
+      },
+      { timeout: defaultTimeout },
+    )
+
+  const explorerUrl = chain.blockExplorers?.default.url
+  if (explorerUrl)
+    test(
+      `${chain.name}: check block explorer`,
+      async () => {
+        await assertExplorerUrl(explorerUrl)
+      },
+      { timeout: defaultTimeout },
+    )
+})
+
+function isLocalNetwork(url: string): boolean {
+  const u = new URL(url)
+  const localNetworkRegex =
+    /^(127\.|10\.|172\.1[6-9]\.|172\.2[0-9]\.|172\.3[0-1]\.|192\.168\.)/
+
+  return localNetworkRegex.test(u.hostname) || u.hostname === 'localhost'
+}
+
+async function assertHttpRpcUrls(
+  chainId: number,
+  rpcUrls: readonly string[],
+): Promise<void> {
+  for (const url of rpcUrls) {
+    if (isLocalNetwork(url)) continue
+    const response = await rpc
+      .http(url, {
+        body: { method: 'eth_chainId' },
+        fetchOptions: { headers: { 'Content-Type': 'application/json' } },
+        timeout: defaultTimeout,
+      })
+      .then((r) => r.result)
+    expect(BigInt(response)).toBe(BigInt(chainId))
+  }
+}
+
+async function assertWebSocketRpcUrls(
+  chainId: number,
+  rpcUrls: readonly string[],
+): Promise<void> {
+  for (const url of rpcUrls) {
+    if (isLocalNetwork(url)) continue
+
+    const socket = await withTimeout(() => getSocket(url), {
+      timeout: defaultTimeout,
+    })
+    const response = await rpc
+      .webSocketAsync(socket, {
+        body: { method: 'eth_chainId' },
+        timeout: defaultTimeout,
+      })
+      .then((r) => r.result)
+    socket.close()
+    expect(BigInt(response)).toBe(BigInt(chainId))
+  }
+}
+
+async function assertExplorerUrl(explorerUrl: string): Promise<void> {
+  await fetch(explorerUrl, { method: 'HEAD' })
+}

test/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "types": ["bun-types"],
+    "baseUrl": ".",
+    "paths": {
+      "~viem/*": ["../src/*"]
+    }
+  }
+}

tsconfig.json

@@ -1,14 +1,14 @@
 {
   // This configuration is used for local development and type checking.
   "extends": "./tsconfig.base.json",
-  "include": ["src", "test"],
+  "include": ["src", "test/src"],
   "exclude": [],
   "references": [{ "path": "./scripts/tsconfig.json" }],
   "compilerOptions": {
     "baseUrl": ".",
     "paths": {
       "~viem/*": ["./src/*"],
-      "~test/*": ["./test/*"],
-    },
+      "~test/*": ["./test/*"]
+    }
   }
 }