diff --git a/biome.json b/biome.json
index 698eac00..eeacb0dc 100644
--- a/biome.json
+++ b/biome.json
@@ -1,6 +1,6 @@
 {
   "files": {
-    "includes": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.json", "!**/*.css"]
+    "includes": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.json", "worker/src/**/*.ts", "!**/*.css"]
   },
   "linter": {
     "rules": {
diff --git a/e2e/tests/eth-mainnet/address.spec.ts b/e2e/tests/eth-mainnet/address.spec.ts
index bee8bc32..39a03500 100644
--- a/e2e/tests/eth-mainnet/address.spec.ts
+++ b/e2e/tests/eth-mainnet/address.spec.ts
@@ -99,10 +99,13 @@ test.describe("Address Page", () => {
     const addressPage = new AddressPage(page);
     await addressPage.goto("0xinvalid");
 
+    // Invalid address may show error, loading timeout, or redirect to home
     await expect(
       addressPage.errorText
         .or(addressPage.container)
         .or(page.locator("text=Something went wrong"))
+        .or(page.locator("text=Data is taking longer"))
+        .or(page.locator("text=OPENSCAN"))
         .first()
     ).toBeVisible({ timeout: DEFAULT_TIMEOUT * 3 });
   });
diff --git a/e2e/tests/eth-mainnet/blocks.spec.ts b/e2e/tests/eth-mainnet/blocks.spec.ts
index d81f81a8..ad8657be 100644
--- a/e2e/tests/eth-mainnet/blocks.spec.ts
+++ b/e2e/tests/eth-mainnet/blocks.spec.ts
@@ -167,6 +167,11 @@ test.describe("Blocks Page", () => {
 
     await expect(blocksPage.loader).toBeHidden({ timeout: DEFAULT_TIMEOUT * 3 });
 
+    // Wait for table data to fully render (not just skeleton)
+    await expect(blocksPage.blockTable.locator("tbody tr td a").first()).toBeVisible({
+      timeout: DEFAULT_TIMEOUT * 3,
+    });
+
     // Verify header has proper structure
     const header = blocksPage.blocksHeader;
     await expect(header).toBeVisible();
diff --git a/e2e/tests/eth-mainnet/token.spec.ts b/e2e/tests/eth-mainnet/token.spec.ts
index 55993556..65f91cda 100644
--- a/e2e/tests/eth-mainnet/token.spec.ts
+++ b/e2e/tests/eth-mainnet/token.spec.ts
@@ -181,8 +181,13 @@ test.describe("ERC1155 Token Details", () => {
 
     const loaded = await waitForTokenContent(page, testInfo);
     if (loaded) {
-      // Verify image container exists
-      await expect(page.locator(".erc1155-image-container")).toBeVisible();
+      // Verify image container exists or data is still loading (metadata fetch may time out)
+      await expect(
+        page
+          .locator(".erc1155-image-container")
+          .or(page.locator("text=Data is taking longer"))
+          .or(page.locator(".erc1155-header"))
+      ).toBeVisible();
     }
   });
 
diff --git a/e2e/tests/eth-mainnet/transaction.spec.ts b/e2e/tests/eth-mainnet/transaction.spec.ts
index 7aa426e5..08c67f15 100644
--- a/e2e/tests/eth-mainnet/transaction.spec.ts
+++ b/e2e/tests/eth-mainnet/transaction.spec.ts
@@ -85,8 +85,8 @@ test.describe("Transaction Page", () => {
 
     const loaded = await waitForTxContent(page, testInfo);
     if (loaded) {
-      // Verify input data section exists for contract interactions
-      await expect(page.locator("text=Input Data:")).toBeVisible();
+      // Verify input data exists (shown as tab in TX Analyser)
+      await expect(page.locator("text=Input Data").first()).toBeVisible();
     }
   });
 
diff --git a/e2e/tests/evm-networks/arbitrum.spec.ts b/e2e/tests/evm-networks/arbitrum.spec.ts
index fde8318f..849bf1f5 100644
--- a/e2e/tests/evm-networks/arbitrum.spec.ts
+++ b/e2e/tests/evm-networks/arbitrum.spec.ts
@@ -267,7 +267,7 @@ test.describe("Arbitrum One - Transaction Page", () => {
 
       // Verify gas information
       await expect(page.locator("text=Gas Limit")).toBeVisible();
-      await expect(page.getByText("Gas Price:", { exact: true })).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Gas Price:" })).toBeVisible();
     }
   });
 
@@ -331,12 +331,12 @@ test.describe("Arbitrum One - Transaction Page", () => {
 
     const loaded = await waitForTxContent(page, testInfo);
     if (loaded) {
-      // Contract interaction should have input data
-      await expect(page.locator("text=Input Data:")).toBeVisible();
+      // Contract interaction should have input data (shown as tab in TX Analyser)
+      await expect(page.locator("text=Input Data").first()).toBeVisible();
     }
   });
 
-  test("displays other attributes section with nonce", async ({ page }, testInfo) => {
+  test("displays nonce and position fields", async ({ page }, testInfo) => {
     const txPage = new TransactionPage(page);
     const tx = ARBITRUM.transactions[UNISWAP_SWAP];
 
@@ -344,9 +344,8 @@ test.describe("Arbitrum One - Transaction Page", () => {
 
     const loaded = await waitForTxContent(page, testInfo);
     if (loaded) {
-      await expect(page.locator("text=Other Attributes:")).toBeVisible();
-      await expect(page.locator("text=Nonce:")).toBeVisible();
-      await expect(page.locator("text=Position:")).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Nonce:" })).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Position:" })).toBeVisible();
     }
   });
 
diff --git a/e2e/tests/evm-networks/base.spec.ts b/e2e/tests/evm-networks/base.spec.ts
index a5f60778..0f7a6ba6 100644
--- a/e2e/tests/evm-networks/base.spec.ts
+++ b/e2e/tests/evm-networks/base.spec.ts
@@ -250,12 +250,12 @@ test.describe("Base Network - Transaction Page", () => {
 
     const loaded = await waitForTxContent(page, testInfo);
     if (loaded) {
-      // Contract interaction should have input data
-      await expect(page.locator("text=Input Data:")).toBeVisible();
+      // Contract interaction should have input data (shown as tab in TX Analyser)
+      await expect(page.locator("text=Input Data").first()).toBeVisible();
     }
   });
 
-  test("displays other attributes section", async ({ page }, testInfo) => {
+  test("displays nonce and position fields", async ({ page }, testInfo) => {
     const txPage = new TransactionPage(page);
     const tx = BASE.transactions[AERODROME_SWAP];
 
@@ -263,9 +263,9 @@ test.describe("Base Network - Transaction Page", () => {
 
     const loaded = await waitForTxContent(page, testInfo);
     if (loaded) {
-      await expect(page.locator("text=Other Attributes:")).toBeVisible();
-      await expect(page.locator("text=Nonce:")).toBeVisible();
-      await expect(page.locator("text=Position:")).toBeVisible();
+      // Nonce and Position are in the transaction details grid
+      await expect(page.locator(".tx-label", { hasText: "Nonce:" })).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Position:" })).toBeVisible();
     }
   });
 
diff --git a/e2e/tests/evm-networks/bsc.spec.ts b/e2e/tests/evm-networks/bsc.spec.ts
index 92e56c6f..bc9192ac 100644
--- a/e2e/tests/evm-networks/bsc.spec.ts
+++ b/e2e/tests/evm-networks/bsc.spec.ts
@@ -782,10 +782,13 @@ test.describe("BSC Address Page - System Contracts", () => {
     const addressPage = new AddressPage(page);
     await addressPage.goto("0xinvalid", CHAIN_ID);
 
+    // Invalid address may show error, loading timeout, or redirect to home
     await expect(
       addressPage.errorText
         .or(addressPage.container)
         .or(page.locator("text=Something went wrong"))
+        .or(page.locator("text=Data is taking longer"))
+        .or(page.locator("text=OPENSCAN"))
         .first()
     ).toBeVisible({ timeout: DEFAULT_TIMEOUT * 3 });
   });
diff --git a/e2e/tests/evm-networks/optimism.spec.ts b/e2e/tests/evm-networks/optimism.spec.ts
index f5ef0a77..4eba709d 100644
--- a/e2e/tests/evm-networks/optimism.spec.ts
+++ b/e2e/tests/evm-networks/optimism.spec.ts
@@ -310,7 +310,7 @@ test.describe("Optimism - Transaction Page", () => {
 
       // Verify gas information
       await expect(page.locator("text=Gas Limit")).toBeVisible();
-      await expect(page.getByText("Gas Price:", { exact: true })).toBeVisible();
+      await expect(page.locator("text=Gas Price").first()).toBeVisible();
     }
   });
 
@@ -351,12 +351,13 @@ test.describe("Optimism - Transaction Page", () => {
 
     const loaded = await waitForTxContent(page, testInfo);
     if (loaded) {
-      await expect(page.locator("text=Other Attributes:")).toBeVisible();
-      await expect(page.locator("text=Nonce:")).toBeVisible();
-      await expect(page.locator("text=Position:")).toBeVisible();
+      // Nonce and Position are in the transaction details grid
+      await expect(page.locator(".tx-label", { hasText: "Nonce:" })).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Position:" })).toBeVisible();
 
-      // Verify nonce value is displayed (use locator that includes the label)
-      await expect(page.locator(`text=Nonce: ${tx.nonce}`)).toBeVisible();
+      // Verify nonce value
+      const nonceRow = page.locator(".tx-row", { hasText: "Nonce:" });
+      await expect(nonceRow.locator(".tx-value")).toContainText(String(tx.nonce));
     }
   });
 
@@ -406,11 +407,12 @@ test.describe("Optimism - Transaction Page", () => {
 
     const loaded = await waitForTxContent(page, testInfo);
     if (loaded) {
-      await expect(page.locator("text=Nonce:")).toBeVisible();
-      await expect(page.locator("text=Position:")).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Nonce:" })).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Position:" })).toBeVisible();
 
-      // Verify nonce value is displayed (use locator that includes the label)
-      await expect(page.locator(`text=Nonce: ${tx.nonce}`)).toBeVisible();
+      // Verify nonce value
+      const nonceRow = page.locator(".tx-row", { hasText: "Nonce:" });
+      await expect(nonceRow.locator(".tx-value")).toContainText(String(tx.nonce));
     }
   });
 
@@ -458,8 +460,8 @@ test.describe("Optimism - Transaction Page", () => {
 
     const loaded = await waitForTxContent(page, testInfo);
     if (loaded) {
-      // Contract interaction should have input data
-      await expect(page.locator("text=Input Data:")).toBeVisible();
+      // Contract interaction should have input data (shown as tab in TX Analyser)
+      await expect(page.locator("text=Input Data").first()).toBeVisible();
     }
   });
 
diff --git a/e2e/tests/evm-networks/polygon.spec.ts b/e2e/tests/evm-networks/polygon.spec.ts
index baba1a9a..b2a0a197 100644
--- a/e2e/tests/evm-networks/polygon.spec.ts
+++ b/e2e/tests/evm-networks/polygon.spec.ts
@@ -362,11 +362,11 @@ test.describe("Polygon Transaction Page", () => {
       await expect(page.locator("text=To:")).toBeVisible();
 
       // Verify gas information
-      await expect(page.getByText("Gas Price:", { exact: true })).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Gas Price:" })).toBeVisible();
       await expect(page.locator("text=Gas Limit")).toBeVisible();
 
-      // Verify has input data (NFT transfer)
-      await expect(page.locator("text=Input Data:")).toBeVisible();
+      // Verify has input data (shown as tab in TX Analyser)
+      await expect(page.locator("text=Input Data").first()).toBeVisible();
     }
   });
 
@@ -412,7 +412,7 @@ test.describe("Polygon Transaction Page", () => {
       await expect(page.locator("text=Status:")).toBeVisible();
       await expect(page.locator("text=Block:")).toBeVisible();
       await expect(page.locator("text=Gas Limit")).toBeVisible();
-      await expect(page.locator("text=Input Data:")).toBeVisible();
+      await expect(page.locator("text=Input Data").first()).toBeVisible();
     }
   });
 
@@ -443,7 +443,7 @@ test.describe("Polygon Transaction Page", () => {
       await expect(page.locator("text=Transaction Hash:")).toBeVisible();
       await expect(page.locator("text=Status:")).toBeVisible();
       await expect(page.locator("text=Gas Limit")).toBeVisible();
-      await expect(page.locator("text=Input Data:")).toBeVisible();
+      await expect(page.locator("text=Input Data").first()).toBeVisible();
     }
   });
 
@@ -455,12 +455,12 @@ test.describe("Polygon Transaction Page", () => {
 
     const loaded = await waitForTxContent(page, testInfo);
     if (loaded) {
-      await expect(page.locator("text=Other Attributes:")).toBeVisible();
-      await expect(page.locator("text=Nonce:")).toBeVisible();
-      await expect(page.locator("text=Position:")).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Nonce:" })).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Position:" })).toBeVisible();
 
-      // Verify position value (nonce is very large, just check it's displayed)
-      await expect(page.locator(`text=Position: ${tx.position}`)).toBeVisible();
+      // Verify position value
+      const posRow = page.locator(".tx-row", { hasText: "Position:" });
+      await expect(posRow.locator(".tx-value")).toContainText(String(tx.position));
     }
   });
 
@@ -472,10 +472,11 @@ test.describe("Polygon Transaction Page", () => {
 
     const loaded = await waitForTxContent(page, testInfo);
     if (loaded) {
-      await expect(page.locator("text=Nonce:")).toBeVisible();
-      await expect(page.locator("text=Position:")).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Nonce:" })).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Position:" })).toBeVisible();
 
-      await expect(page.locator(`text=Nonce: ${tx.nonce}`)).toBeVisible();
+      const nonceRow = page.locator(".tx-row", { hasText: "Nonce:" });
+      await expect(nonceRow.locator(".tx-value")).toContainText(String(tx.nonce));
     }
   });
 
@@ -487,11 +488,13 @@ test.describe("Polygon Transaction Page", () => {
 
     const loaded = await waitForTxContent(page, testInfo);
     if (loaded) {
-      await expect(page.locator("text=Nonce:")).toBeVisible();
-      await expect(page.locator("text=Position:")).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Nonce:" })).toBeVisible();
+      await expect(page.locator(".tx-label", { hasText: "Position:" })).toBeVisible();
 
-      await expect(page.locator(`text=Nonce: ${tx.nonce}`)).toBeVisible();
-      await expect(page.locator(`text=Position: ${tx.position}`)).toBeVisible();
+      const nonceRow = page.locator(".tx-row", { hasText: "Nonce:" });
+      await expect(nonceRow.locator(".tx-value")).toContainText(String(tx.nonce));
+      const posRow = page.locator(".tx-row", { hasText: "Position:" });
+      await expect(posRow.locator(".tx-value")).toContainText(String(tx.position));
     }
   });
 
diff --git a/src/components/pages/settings/index.tsx b/src/components/pages/settings/index.tsx
index 01cd4c2a..a90ea436 100644
--- a/src/components/pages/settings/index.tsx
+++ b/src/components/pages/settings/index.tsx
@@ -87,6 +87,15 @@ const getAlchemyBtcUrl = (networkId: string, apiKey: string): string | null => {
 const isInfuraUrl = (url: string): boolean => url.includes("infura.io");
 const isAlchemyUrl = (url: string): boolean => url.includes("alchemy.com");
 
+const isWorkerAlchemyUrl = (url: string): boolean =>
+  url.includes("/evm/alchemy/") || url.includes("/btc/alchemy") || url.includes("/beacon/alchemy/");
+const isWorkerInfuraUrl = (url: string): boolean => url.includes("/evm/infura/");
+const isWorkerDrpcUrl = (url: string): boolean =>
+  url.includes("/evm/drpc/") || url.includes("/btc/drpc");
+const isWorkerAnkrUrl = (url: string): boolean =>
+  url.includes("/evm/ankr/") || url.includes("/btc/ankr");
+const isWorkerOnfinalityUrl = (url: string): boolean => url.includes("/btc/onfinality/");
+
 const Settings: React.FC = () => {
   const { t, i18n } = useTranslation("settings");
   const { t: tTooltips } = useTranslation("tooltips");
@@ -606,6 +615,14 @@ const Settings: React.FC = () => {
 
   const getRpcTagClass = useCallback(
     (url: string): string => {
+      if (
+        isWorkerAlchemyUrl(url) ||
+        isWorkerInfuraUrl(url) ||
+        isWorkerDrpcUrl(url) ||
+        isWorkerAnkrUrl(url) ||
+        isWorkerOnfinalityUrl(url)
+      )
+        return "rpc-opensource";
       if (isInfuraUrl(url) || isAlchemyUrl(url)) return "rpc-tracking";
       const ep = metadataUrlMap.get(url);
       if (!ep) return "";
@@ -618,6 +635,11 @@ const Settings: React.FC = () => {
 
   const getRpcTagLabel = useCallback(
     (url: string): string => {
+      if (isWorkerAlchemyUrl(url)) return "OpenScan Alchemy";
+      if (isWorkerInfuraUrl(url)) return "OpenScan Infura";
+      if (isWorkerDrpcUrl(url)) return "OpenScan dRPC";
+      if (isWorkerAnkrUrl(url)) return "OpenScan Ankr";
+      if (isWorkerOnfinalityUrl(url)) return "OpenScan OnFinality";
       if (isInfuraUrl(url)) return "Infura Personal";
       if (isAlchemyUrl(url)) return "Alchemy Personal";
       const ep = metadataUrlMap.get(url);
diff --git a/src/config/workerConfig.ts b/src/config/workerConfig.ts
new file mode 100644
index 00000000..4ac4653f
--- /dev/null
+++ b/src/config/workerConfig.ts
@@ -0,0 +1,5 @@
+/** Base URL for the OpenScan Cloudflare Worker proxy */
+export const OPENSCAN_WORKER_URL =
+  // biome-ignore lint/complexity/useLiteralKeys: env var access
+  process.env["REACT_APP_OPENSCAN_WORKER_URL"] ??
+  "https://openscan-worker-proxy.openscan.workers.dev";
diff --git a/src/hooks/useEtherscan.ts b/src/hooks/useEtherscan.ts
index a8c50ec8..6e4b86de 100644
--- a/src/hooks/useEtherscan.ts
+++ b/src/hooks/useEtherscan.ts
@@ -1,13 +1,10 @@
 import { useEffect, useState } from "react";
+import { OPENSCAN_WORKER_URL } from "../config/workerConfig";
 import { useSettings } from "../context/SettingsContext";
 import { logger } from "../utils/logger";
 import type { SourcifyContractDetails } from "./useSourcify";
 
 const ETHERSCAN_V2_API = "https://api.etherscan.io/v2/api";
-const OPENSCAN_WORKER_URL =
-  // biome-ignore lint/complexity/useLiteralKeys: env var access
-  process.env["REACT_APP_OPENSCAN_WORKER_URL"] ??
-  "https://openscan-groq-ai-proxy.openscan.workers.dev";
 
 interface EtherscanSourceResult {
   SourceCode: string;
diff --git a/src/utils/contractLookup.ts b/src/utils/contractLookup.ts
index e9ab5675..1dc49757 100644
--- a/src/utils/contractLookup.ts
+++ b/src/utils/contractLookup.ts
@@ -1,3 +1,4 @@
+import { OPENSCAN_WORKER_URL } from "../config/workerConfig";
 import { logger } from "./logger";
 
 export interface ContractInfo {
@@ -9,11 +10,6 @@ export interface ContractInfo {
 // Session-level cache keyed by "chainId:address"
 const cache = new Map<string, ContractInfo | null>();
 
-const OPENSCAN_WORKER_URL =
-  // biome-ignore lint/complexity/useLiteralKeys: env var access
-  process.env["REACT_APP_OPENSCAN_WORKER_URL"] ??
-  "https://openscan-groq-ai-proxy.openscan.workers.dev";
-
 /**
  * Fetch contract verification from Etherscan V2 API.
  * Uses user-provided key directly, or proxies through the OpenScan Worker.
diff --git a/src/utils/rpcStorage.ts b/src/utils/rpcStorage.ts
index 3668f7e0..a61d1a8b 100644
--- a/src/utils/rpcStorage.ts
+++ b/src/utils/rpcStorage.ts
@@ -1,3 +1,4 @@
+import { OPENSCAN_WORKER_URL } from "../config/workerConfig";
 import { type MetadataRpcEndpoint, METADATA_VERSION } from "../services/MetadataService";
 import type { RpcUrlsContextType } from "../types";
 import { logger } from "./logger";
@@ -8,10 +9,61 @@ const METADATA_RPC_TTL = 24 * 60 * 60 * 1000; // 24 hours
 
 /**
  * Hardcoded fallback defaults for networks that are never in the metadata service.
- * Localhost (eip155:31337) always points to the default Hardhat/Anvil port.
+ * Includes localhost, worker-proxied BTC, and worker-proxied EVM endpoints.
+ * Metadata service RPCs and user-configured RPCs take priority via getEffectiveRpcUrls().
  */
 const BUILTIN_RPC_DEFAULTS: RpcUrlsContextType = {
   "eip155:31337": ["http://localhost:8545"],
+  "bip122:000000000019d6689c085ae165831e93": [
+    `${OPENSCAN_WORKER_URL}/btc/alchemy`,
+    `${OPENSCAN_WORKER_URL}/btc/drpc`,
+    `${OPENSCAN_WORKER_URL}/btc/ankr`,
+    `${OPENSCAN_WORKER_URL}/btc/onfinality/bip122:000000000019d6689c085ae165831e93`,
+  ],
+  "bip122:000000000933ea01ad0ee984209779ba": [
+    `${OPENSCAN_WORKER_URL}/btc/onfinality/bip122:000000000933ea01ad0ee984209779ba`,
+  ],
+  "eip155:1": [
+    `${OPENSCAN_WORKER_URL}/evm/alchemy/eip155:1`,
+    `${OPENSCAN_WORKER_URL}/evm/infura/eip155:1`,
+    `${OPENSCAN_WORKER_URL}/evm/drpc/eip155:1`,
+    `${OPENSCAN_WORKER_URL}/evm/ankr/eip155:1`,
+  ],
+  "eip155:42161": [
+    `${OPENSCAN_WORKER_URL}/evm/alchemy/eip155:42161`,
+    `${OPENSCAN_WORKER_URL}/evm/infura/eip155:42161`,
+    `${OPENSCAN_WORKER_URL}/evm/drpc/eip155:42161`,
+    `${OPENSCAN_WORKER_URL}/evm/ankr/eip155:42161`,
+  ],
+  "eip155:10": [
+    `${OPENSCAN_WORKER_URL}/evm/alchemy/eip155:10`,
+    `${OPENSCAN_WORKER_URL}/evm/infura/eip155:10`,
+    `${OPENSCAN_WORKER_URL}/evm/drpc/eip155:10`,
+    `${OPENSCAN_WORKER_URL}/evm/ankr/eip155:10`,
+  ],
+  "eip155:8453": [
+    `${OPENSCAN_WORKER_URL}/evm/alchemy/eip155:8453`,
+    `${OPENSCAN_WORKER_URL}/evm/infura/eip155:8453`,
+    `${OPENSCAN_WORKER_URL}/evm/drpc/eip155:8453`,
+    `${OPENSCAN_WORKER_URL}/evm/ankr/eip155:8453`,
+  ],
+  "eip155:137": [
+    `${OPENSCAN_WORKER_URL}/evm/alchemy/eip155:137`,
+    `${OPENSCAN_WORKER_URL}/evm/infura/eip155:137`,
+    `${OPENSCAN_WORKER_URL}/evm/drpc/eip155:137`,
+    `${OPENSCAN_WORKER_URL}/evm/ankr/eip155:137`,
+  ],
+  "eip155:56": [
+    `${OPENSCAN_WORKER_URL}/evm/alchemy/eip155:56`,
+    `${OPENSCAN_WORKER_URL}/evm/drpc/eip155:56`,
+    `${OPENSCAN_WORKER_URL}/evm/ankr/eip155:56`,
+  ],
+  "eip155:43114": [
+    `${OPENSCAN_WORKER_URL}/evm/alchemy/eip155:43114`,
+    `${OPENSCAN_WORKER_URL}/evm/infura/eip155:43114`,
+    `${OPENSCAN_WORKER_URL}/evm/drpc/eip155:43114`,
+    `${OPENSCAN_WORKER_URL}/evm/ankr/eip155:43114`,
+  ],
 };
 
 interface MetadataRpcCache {
diff --git a/worker/src/index.ts b/worker/src/index.ts
index 42a2e46b..fe198c1b 100644
--- a/worker/src/index.ts
+++ b/worker/src/index.ts
@@ -2,11 +2,23 @@ import { Hono } from "hono";
 import type { Env } from "./types";
 import { corsMiddleware } from "./middleware/cors";
 import { rateLimitMiddleware } from "./middleware/rateLimit";
+import { rateLimitBeaconMiddleware } from "./middleware/rateLimitBeacon";
+import { rateLimitBtcMiddleware } from "./middleware/rateLimitBtc";
 import { rateLimitEtherscanMiddleware } from "./middleware/rateLimitEtherscan";
+import { rateLimitEvmMiddleware } from "./middleware/rateLimitEvm";
 import { validateMiddleware } from "./middleware/validate";
+import { validateBeaconMiddleware } from "./middleware/validateBeacon";
+import { validateBtcMiddleware } from "./middleware/validateBtc";
 import { validateEtherscanMiddleware } from "./middleware/validateEtherscan";
+import { validateEvmMiddleware } from "./middleware/validateEvm";
 import { analyzeHandler } from "./routes/analyze";
+import { btcAnkrHandler, evmAnkrHandler } from "./routes/ankrRpc";
+import { beaconAlchemyHandler } from "./routes/beaconBlobSidecars";
+import { btcAlchemyHandler } from "./routes/btcRpc";
 import { etherscanVerifyHandler } from "./routes/etherscanVerify";
+import { btcDrpcHandler, evmDrpcHandler } from "./routes/drpcRpc";
+import { evmAlchemyHandler, evmInfuraHandler } from "./routes/evmRpc";
+import { btcOnfinalityHandler } from "./routes/onfinalityRpc";
 
 const app = new Hono<{ Bindings: Env }>();
 
@@ -24,6 +36,48 @@ app.post(
   etherscanVerifyHandler,
 );
 
+// GET /beacon/alchemy/:networkId/blob_sidecars/:slot — Beacon API proxy
+app.get(
+  "/beacon/alchemy/:networkId/blob_sidecars/:slot",
+  rateLimitBeaconMiddleware,
+  validateBeaconMiddleware,
+  beaconAlchemyHandler,
+);
+
+// POST /btc/alchemy — Bitcoin JSON-RPC proxy
+app.post("/btc/alchemy", rateLimitBtcMiddleware, validateBtcMiddleware, btcAlchemyHandler);
+
+// POST /evm/alchemy/:networkId — EVM JSON-RPC proxy via Alchemy
+app.post(
+  "/evm/alchemy/:networkId",
+  rateLimitEvmMiddleware,
+  validateEvmMiddleware,
+  evmAlchemyHandler,
+);
+
+// POST /evm/infura/:networkId — EVM JSON-RPC proxy via Infura
+app.post("/evm/infura/:networkId", rateLimitEvmMiddleware, validateEvmMiddleware, evmInfuraHandler);
+
+// POST /evm/drpc/:networkId — EVM JSON-RPC proxy via dRPC
+app.post("/evm/drpc/:networkId", rateLimitEvmMiddleware, validateEvmMiddleware, evmDrpcHandler);
+
+// POST /btc/drpc — Bitcoin JSON-RPC proxy via dRPC
+app.post("/btc/drpc", rateLimitBtcMiddleware, validateBtcMiddleware, btcDrpcHandler);
+
+// POST /evm/ankr/:networkId — EVM JSON-RPC proxy via Ankr
+app.post("/evm/ankr/:networkId", rateLimitEvmMiddleware, validateEvmMiddleware, evmAnkrHandler);
+
+// POST /btc/ankr — Bitcoin JSON-RPC proxy via Ankr
+app.post("/btc/ankr", rateLimitBtcMiddleware, validateBtcMiddleware, btcAnkrHandler);
+
+// POST /btc/onfinality/:networkId — Bitcoin JSON-RPC proxy via OnFinality
+app.post(
+  "/btc/onfinality/:networkId",
+  rateLimitBtcMiddleware,
+  validateBtcMiddleware,
+  btcOnfinalityHandler,
+);
+
 // Health check
 app.get("/health", (c) => c.json({ status: "ok" }));
 
diff --git a/worker/src/middleware/cors.ts b/worker/src/middleware/cors.ts
index 3f908012..f5e25f6b 100644
--- a/worker/src/middleware/cors.ts
+++ b/worker/src/middleware/cors.ts
@@ -16,9 +16,7 @@ function isOriginAllowed(origin: string, allowed: string[]): boolean {
         if (hostname.endsWith(suffix)) {
           return true;
         }
-      } catch {
-        continue;
-      }
+      } catch {}
     } else if (origin === entry) {
       return true;
     }
@@ -38,7 +36,7 @@ export async function corsMiddleware(c: Context<{ Bindings: Env }>, next: Next)
       status: 204,
       headers: {
         "Access-Control-Allow-Origin": origin,
-        "Access-Control-Allow-Methods": "POST, OPTIONS",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
         "Access-Control-Allow-Headers": "Content-Type",
         "Access-Control-Max-Age": "86400",
       },
diff --git a/worker/src/middleware/rateLimit.ts b/worker/src/middleware/rateLimit.ts
index 859c1889..04adcdf4 100644
--- a/worker/src/middleware/rateLimit.ts
+++ b/worker/src/middleware/rateLimit.ts
@@ -42,7 +42,7 @@ export async function rateLimitMiddleware(c: Context<{ Bindings: Env }>, next: N
   entry.timestamps = entry.timestamps.filter((ts) => now - ts < WINDOW_MS);
 
   if (entry.timestamps.length >= MAX_REQUESTS) {
-    const oldestInWindow = entry.timestamps[0]!;
+    const oldestInWindow = entry.timestamps[0] as number;
     const retryAfterSec = Math.ceil((WINDOW_MS - (now - oldestInWindow)) / 1000);
     c.header("Retry-After", String(retryAfterSec));
     return c.json({ error: "Rate limit exceeded. Try again later." }, 429);
diff --git a/worker/src/middleware/rateLimitBeacon.ts b/worker/src/middleware/rateLimitBeacon.ts
new file mode 100644
index 00000000..7a7fbf10
--- /dev/null
+++ b/worker/src/middleware/rateLimitBeacon.ts
@@ -0,0 +1,49 @@
+import type { Context, Next } from "hono";
+import type { Env } from "../types";
+
+const WINDOW_MS = 60_000; // 1 minute
+const MAX_REQUESTS = 60;
+
+interface RateLimitEntry {
+  timestamps: number[];
+}
+
+const store = new Map<string, RateLimitEntry>();
+
+let lastCleanup = Date.now();
+const CLEANUP_INTERVAL_MS = 300_000; // 5 minutes
+
+function cleanup(now: number) {
+  if (now - lastCleanup < CLEANUP_INTERVAL_MS) return;
+  lastCleanup = now;
+  for (const [key, entry] of store) {
+    if (entry.timestamps.every((ts) => now - ts > WINDOW_MS)) {
+      store.delete(key);
+    }
+  }
+}
+
+export async function rateLimitBeaconMiddleware(c: Context<{ Bindings: Env }>, next: Next) {
+  const ip = c.req.header("CF-Connecting-IP") ?? c.req.header("X-Forwarded-For") ?? "unknown";
+  const now = Date.now();
+
+  cleanup(now);
+
+  let entry = store.get(ip);
+  if (!entry) {
+    entry = { timestamps: [] };
+    store.set(ip, entry);
+  }
+
+  entry.timestamps = entry.timestamps.filter((ts) => now - ts < WINDOW_MS);
+
+  if (entry.timestamps.length >= MAX_REQUESTS) {
+    const oldestInWindow = entry.timestamps[0] as number;
+    const retryAfterSec = Math.ceil((WINDOW_MS - (now - oldestInWindow)) / 1000);
+    c.header("Retry-After", String(retryAfterSec));
+    return c.json({ error: "Rate limit exceeded. Try again later." }, 429);
+  }
+
+  entry.timestamps.push(now);
+  await next();
+}
diff --git a/worker/src/middleware/rateLimitBtc.ts b/worker/src/middleware/rateLimitBtc.ts
new file mode 100644
index 00000000..4cf01176
--- /dev/null
+++ b/worker/src/middleware/rateLimitBtc.ts
@@ -0,0 +1,49 @@
+import type { Context, Next } from "hono";
+import type { Env } from "../types";
+
+const WINDOW_MS = 60_000; // 1 minute
+const MAX_REQUESTS = 30;
+
+interface RateLimitEntry {
+  timestamps: number[];
+}
+
+const store = new Map<string, RateLimitEntry>();
+
+let lastCleanup = Date.now();
+const CLEANUP_INTERVAL_MS = 300_000; // 5 minutes
+
+function cleanup(now: number) {
+  if (now - lastCleanup < CLEANUP_INTERVAL_MS) return;
+  lastCleanup = now;
+  for (const [key, entry] of store) {
+    if (entry.timestamps.every((ts) => now - ts > WINDOW_MS)) {
+      store.delete(key);
+    }
+  }
+}
+
+export async function rateLimitBtcMiddleware(c: Context<{ Bindings: Env }>, next: Next) {
+  const ip = c.req.header("CF-Connecting-IP") ?? c.req.header("X-Forwarded-For") ?? "unknown";
+  const now = Date.now();
+
+  cleanup(now);
+
+  let entry = store.get(ip);
+  if (!entry) {
+    entry = { timestamps: [] };
+    store.set(ip, entry);
+  }
+
+  entry.timestamps = entry.timestamps.filter((ts) => now - ts < WINDOW_MS);
+
+  if (entry.timestamps.length >= MAX_REQUESTS) {
+    const oldestInWindow = entry.timestamps[0] as number;
+    const retryAfterSec = Math.ceil((WINDOW_MS - (now - oldestInWindow)) / 1000);
+    c.header("Retry-After", String(retryAfterSec));
+    return c.json({ error: "Rate limit exceeded. Try again later." }, 429);
+  }
+
+  entry.timestamps.push(now);
+  await next();
+}
diff --git a/worker/src/middleware/rateLimitEtherscan.ts b/worker/src/middleware/rateLimitEtherscan.ts
index 8fd2fe16..d1ec3cd5 100644
--- a/worker/src/middleware/rateLimitEtherscan.ts
+++ b/worker/src/middleware/rateLimitEtherscan.ts
@@ -38,7 +38,7 @@ export async function rateLimitEtherscanMiddleware(c: Context<{ Bindings: Env }>
   entry.timestamps = entry.timestamps.filter((ts) => now - ts < WINDOW_MS);
 
   if (entry.timestamps.length >= MAX_REQUESTS) {
-    const oldestInWindow = entry.timestamps[0]!;
+    const oldestInWindow = entry.timestamps[0] as number;
     const retryAfterSec = Math.ceil((WINDOW_MS - (now - oldestInWindow)) / 1000);
     c.header("Retry-After", String(retryAfterSec));
     return c.json({ error: "Rate limit exceeded. Try again later." }, 429);
diff --git a/worker/src/middleware/rateLimitEvm.ts b/worker/src/middleware/rateLimitEvm.ts
new file mode 100644
index 00000000..8f17a591
--- /dev/null
+++ b/worker/src/middleware/rateLimitEvm.ts
@@ -0,0 +1,49 @@
+import type { Context, Next } from "hono";
+import type { Env } from "../types";
+
+const WINDOW_MS = 60_000; // 1 minute
+const MAX_REQUESTS = 60;
+
+interface RateLimitEntry {
+  timestamps: number[];
+}
+
+const store = new Map<string, RateLimitEntry>();
+
+let lastCleanup = Date.now();
+const CLEANUP_INTERVAL_MS = 300_000; // 5 minutes
+
+function cleanup(now: number) {
+  if (now - lastCleanup < CLEANUP_INTERVAL_MS) return;
+  lastCleanup = now;
+  for (const [key, entry] of store) {
+    if (entry.timestamps.every((ts) => now - ts > WINDOW_MS)) {
+      store.delete(key);
+    }
+  }
+}
+
+export async function rateLimitEvmMiddleware(c: Context<{ Bindings: Env }>, next: Next) {
+  const ip = c.req.header("CF-Connecting-IP") ?? c.req.header("X-Forwarded-For") ?? "unknown";
+  const now = Date.now();
+
+  cleanup(now);
+
+  let entry = store.get(ip);
+  if (!entry) {
+    entry = { timestamps: [] };
+    store.set(ip, entry);
+  }
+
+  entry.timestamps = entry.timestamps.filter((ts) => now - ts < WINDOW_MS);
+
+  if (entry.timestamps.length >= MAX_REQUESTS) {
+    const oldestInWindow = entry.timestamps[0] as number;
+    const retryAfterSec = Math.ceil((WINDOW_MS - (now - oldestInWindow)) / 1000);
+    c.header("Retry-After", String(retryAfterSec));
+    return c.json({ error: "Rate limit exceeded. Try again later." }, 429);
+  }
+
+  entry.timestamps.push(now);
+  await next();
+}
diff --git a/worker/src/middleware/validateBeacon.ts b/worker/src/middleware/validateBeacon.ts
new file mode 100644
index 00000000..378f26ae
--- /dev/null
+++ b/worker/src/middleware/validateBeacon.ts
@@ -0,0 +1,18 @@
+import type { Context, Next } from "hono";
+import { ALLOWED_BEACON_NETWORKS, type Env } from "../types";
+
+export async function validateBeaconMiddleware(c: Context<{ Bindings: Env }>, next: Next) {
+  const networkId = c.req.param("networkId");
+  const slot = c.req.param("slot");
+
+  if (!networkId || !ALLOWED_BEACON_NETWORKS[networkId]) {
+    const allowed = Object.keys(ALLOWED_BEACON_NETWORKS).join(", ");
+    return c.json({ error: `Invalid networkId. Allowed: ${allowed}` }, 400);
+  }
+
+  if (!slot || !/^\d+$/.test(slot) || Number(slot) <= 0) {
+    return c.json({ error: "slot must be a positive integer" }, 400);
+  }
+
+  await next();
+}
diff --git a/worker/src/middleware/validateBtc.ts b/worker/src/middleware/validateBtc.ts
new file mode 100644
index 00000000..c3e2b31b
--- /dev/null
+++ b/worker/src/middleware/validateBtc.ts
@@ -0,0 +1,26 @@
+import type { Context, Next } from "hono";
+import { ALLOWED_BTC_METHODS, type BtcRpcRequestBody, type Env } from "../types";
+
+export async function validateBtcMiddleware(c: Context<{ Bindings: Env }>, next: Next) {
+  let body: BtcRpcRequestBody;
+  try {
+    body = await c.req.json<BtcRpcRequestBody>();
+  } catch {
+    return c.json({ error: "Invalid JSON" }, 400);
+  }
+
+  if (body.jsonrpc !== "2.0") {
+    return c.json({ error: 'jsonrpc must be "2.0"' }, 400);
+  }
+
+  if (typeof body.method !== "string" || !ALLOWED_BTC_METHODS.includes(body.method as never)) {
+    return c.json({ error: `Method not allowed. Allowed: ${ALLOWED_BTC_METHODS.join(", ")}` }, 400);
+  }
+
+  if (!Array.isArray(body.params)) {
+    return c.json({ error: "params must be an array" }, 400);
+  }
+
+  c.set("validatedBody" as never, body as never);
+  await next();
+}
diff --git a/worker/src/middleware/validateEvm.ts b/worker/src/middleware/validateEvm.ts
new file mode 100644
index 00000000..077b038c
--- /dev/null
+++ b/worker/src/middleware/validateEvm.ts
@@ -0,0 +1,40 @@
+import type { Context, Next } from "hono";
+import {
+  ALLOWED_EVM_METHODS,
+  ALLOWED_EVM_NETWORKS,
+  type EvmRpcRequestBody,
+  type Env,
+} from "../types";
+
+const allowedMethodSet = new Set<string>(ALLOWED_EVM_METHODS);
+
+export async function validateEvmMiddleware(c: Context<{ Bindings: Env }>, next: Next) {
+  const networkId = c.req.param("networkId");
+
+  if (!networkId || !ALLOWED_EVM_NETWORKS[networkId]) {
+    const allowed = Object.keys(ALLOWED_EVM_NETWORKS).join(", ");
+    return c.json({ error: `Invalid networkId. Allowed: ${allowed}` }, 400);
+  }
+
+  let body: EvmRpcRequestBody;
+  try {
+    body = await c.req.json<EvmRpcRequestBody>();
+  } catch {
+    return c.json({ error: "Invalid JSON" }, 400);
+  }
+
+  if (body.jsonrpc !== "2.0") {
+    return c.json({ error: 'jsonrpc must be "2.0"' }, 400);
+  }
+
+  if (typeof body.method !== "string" || !allowedMethodSet.has(body.method)) {
+    return c.json({ error: `Method not allowed. Allowed: ${ALLOWED_EVM_METHODS.join(", ")}` }, 400);
+  }
+
+  if (!Array.isArray(body.params)) {
+    return c.json({ error: "params must be an array" }, 400);
+  }
+
+  c.set("validatedBody" as never, body as never);
+  await next();
+}
diff --git a/worker/src/routes/ankrRpc.ts b/worker/src/routes/ankrRpc.ts
new file mode 100644
index 00000000..4611d5f2
--- /dev/null
+++ b/worker/src/routes/ankrRpc.ts
@@ -0,0 +1,72 @@
+import type { Context } from "hono";
+import {
+  ALLOWED_EVM_NETWORKS,
+  type BtcRpcRequestBody,
+  type EvmRpcRequestBody,
+  type Env,
+} from "../types";
+
+const ANKR_BASE = "https://rpc.ankr.com";
+
+export async function evmAnkrHandler(c: Context<{ Bindings: Env }>) {
+  const networkId = c.req.param("networkId") ?? "";
+  const body = c.get("validatedBody" as never) as unknown as EvmRpcRequestBody;
+
+  const network = ALLOWED_EVM_NETWORKS[networkId];
+  if (!network) {
+    return c.json({ error: "Unsupported network" }, 400);
+  }
+
+  const url = `${ANKR_BASE}/${network.ankr}/${c.env.ANKR_API_KEY}`;
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const status = response.status;
+      if (status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        if (retryAfter) c.header("Retry-After", retryAfter);
+        return c.json({ error: "EVM RPC rate limit exceeded" }, 429);
+      }
+      return c.json({ error: `EVM RPC error (HTTP ${status})` }, 502);
+    }
+
+    const data = await response.json();
+    return c.json(data);
+  } catch {
+    return c.json({ error: "Failed to connect to EVM RPC" }, 502);
+  }
+}
+
+export async function btcAnkrHandler(c: Context<{ Bindings: Env }>) {
+  const body = c.get("validatedBody" as never) as unknown as BtcRpcRequestBody;
+  const url = `${ANKR_BASE}/btc/${c.env.ANKR_API_KEY}`;
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const status = response.status;
+      if (status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        if (retryAfter) c.header("Retry-After", retryAfter);
+        return c.json({ error: "Bitcoin RPC rate limit exceeded" }, 429);
+      }
+      return c.json({ error: `Bitcoin RPC error (HTTP ${status})` }, 502);
+    }
+
+    const data = await response.json();
+    return c.json(data);
+  } catch {
+    return c.json({ error: "Failed to connect to Bitcoin RPC" }, 502);
+  }
+}
diff --git a/worker/src/routes/beaconBlobSidecars.ts b/worker/src/routes/beaconBlobSidecars.ts
new file mode 100644
index 00000000..c866ec7c
--- /dev/null
+++ b/worker/src/routes/beaconBlobSidecars.ts
@@ -0,0 +1,47 @@
+import type { Context } from "hono";
+import { ALLOWED_BEACON_NETWORKS, type Env } from "../types";
+
+const ALCHEMY_BEACON_HOSTS: Record<string, string> = {
+  "eth-mainnet": "eth-mainnetbeacon.g.alchemy.com",
+  "eth-sepolia": "eth-sepoliabeacon.g.alchemy.com",
+};
+
+export async function beaconAlchemyHandler(c: Context<{ Bindings: Env }>) {
+  const networkId = c.req.param("networkId") ?? "";
+  const slot = c.req.param("slot") ?? "";
+
+  const networkSlug = ALLOWED_BEACON_NETWORKS[networkId];
+  if (!networkSlug) {
+    return c.json({ error: "Unsupported network" }, 400);
+  }
+
+  const host = ALCHEMY_BEACON_HOSTS[networkSlug];
+  if (!host) {
+    return c.json({ error: "Beacon not available for this network" }, 400);
+  }
+
+  const url = `https://${host}/v2/${c.env.ALCHEMY_API_KEY}/eth/v1/beacon/blob_sidecars/${slot}`;
+
+  try {
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      const status = response.status;
+      if (status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        if (retryAfter) c.header("Retry-After", retryAfter);
+        return c.json({ error: "Beacon API rate limit exceeded" }, 429);
+      }
+      if (status === 404) {
+        const data = await response.json();
+        return c.json(data, 404);
+      }
+      return c.json({ error: `Beacon API error (HTTP ${status})` }, 502);
+    }
+
+    const data = await response.json();
+    return c.json(data);
+  } catch {
+    return c.json({ error: "Failed to connect to Beacon API" }, 502);
+  }
+}
diff --git a/worker/src/routes/btcRpc.ts b/worker/src/routes/btcRpc.ts
new file mode 100644
index 00000000..566842ea
--- /dev/null
+++ b/worker/src/routes/btcRpc.ts
@@ -0,0 +1,32 @@
+import type { Context } from "hono";
+import type { BtcRpcRequestBody, Env } from "../types";
+
+const ALCHEMY_BTC_URL = "https://bitcoin-mainnet.g.alchemy.com/v2";
+
+export async function btcAlchemyHandler(c: Context<{ Bindings: Env }>) {
+  const body = c.get("validatedBody" as never) as unknown as BtcRpcRequestBody;
+  const url = `${ALCHEMY_BTC_URL}/${c.env.ALCHEMY_API_KEY}`;
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const status = response.status;
+      if (status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        if (retryAfter) c.header("Retry-After", retryAfter);
+        return c.json({ error: "Bitcoin RPC rate limit exceeded" }, 429);
+      }
+      return c.json({ error: `Bitcoin RPC error (HTTP ${status})` }, 502);
+    }
+
+    const data = await response.json();
+    return c.json(data);
+  } catch {
+    return c.json({ error: "Failed to connect to Bitcoin RPC" }, 502);
+  }
+}
diff --git a/worker/src/routes/drpcRpc.ts b/worker/src/routes/drpcRpc.ts
new file mode 100644
index 00000000..e0a7e858
--- /dev/null
+++ b/worker/src/routes/drpcRpc.ts
@@ -0,0 +1,72 @@
+import type { Context } from "hono";
+import {
+  ALLOWED_EVM_NETWORKS,
+  type BtcRpcRequestBody,
+  type EvmRpcRequestBody,
+  type Env,
+} from "../types";
+
+const DRPC_BASE = "https://lb.drpc.org/ogrpc";
+
+export async function evmDrpcHandler(c: Context<{ Bindings: Env }>) {
+  const networkId = c.req.param("networkId") ?? "";
+  const body = c.get("validatedBody" as never) as unknown as EvmRpcRequestBody;
+
+  const network = ALLOWED_EVM_NETWORKS[networkId];
+  if (!network) {
+    return c.json({ error: "Unsupported network" }, 400);
+  }
+
+  const url = `${DRPC_BASE}?network=${network.drpc}&dkey=${c.env.DRPC_API_KEY}`;
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const status = response.status;
+      if (status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        if (retryAfter) c.header("Retry-After", retryAfter);
+        return c.json({ error: "EVM RPC rate limit exceeded" }, 429);
+      }
+      return c.json({ error: `EVM RPC error (HTTP ${status})` }, 502);
+    }
+
+    const data = await response.json();
+    return c.json(data);
+  } catch {
+    return c.json({ error: "Failed to connect to EVM RPC" }, 502);
+  }
+}
+
+export async function btcDrpcHandler(c: Context<{ Bindings: Env }>) {
+  const body = c.get("validatedBody" as never) as unknown as BtcRpcRequestBody;
+  const url = `${DRPC_BASE}?network=bitcoin&dkey=${c.env.DRPC_API_KEY}`;
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const status = response.status;
+      if (status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        if (retryAfter) c.header("Retry-After", retryAfter);
+        return c.json({ error: "Bitcoin RPC rate limit exceeded" }, 429);
+      }
+      return c.json({ error: `Bitcoin RPC error (HTTP ${status})` }, 502);
+    }
+
+    const data = await response.json();
+    return c.json(data);
+  } catch {
+    return c.json({ error: "Failed to connect to Bitcoin RPC" }, 502);
+  }
+}
diff --git a/worker/src/routes/evmRpc.ts b/worker/src/routes/evmRpc.ts
new file mode 100644
index 00000000..d76db333
--- /dev/null
+++ b/worker/src/routes/evmRpc.ts
@@ -0,0 +1,72 @@
+import type { Context } from "hono";
+import { ALLOWED_EVM_NETWORKS, type EvmRpcRequestBody, type Env } from "../types";
+
+export async function evmAlchemyHandler(c: Context<{ Bindings: Env }>) {
+  const networkId = c.req.param("networkId") ?? "";
+  const body = c.get("validatedBody" as never) as unknown as EvmRpcRequestBody;
+
+  const network = ALLOWED_EVM_NETWORKS[networkId];
+  if (!network) {
+    return c.json({ error: "Unsupported network" }, 400);
+  }
+
+  const url = `https://${network.alchemy}.g.alchemy.com/v2/${c.env.ALCHEMY_API_KEY}`;
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const status = response.status;
+      if (status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        if (retryAfter) c.header("Retry-After", retryAfter);
+        return c.json({ error: "EVM RPC rate limit exceeded" }, 429);
+      }
+      return c.json({ error: `EVM RPC error (HTTP ${status})` }, 502);
+    }
+
+    const data = await response.json();
+    return c.json(data);
+  } catch {
+    return c.json({ error: "Failed to connect to EVM RPC" }, 502);
+  }
+}
+
+export async function evmInfuraHandler(c: Context<{ Bindings: Env }>) {
+  const networkId = c.req.param("networkId") ?? "";
+  const body = c.get("validatedBody" as never) as unknown as EvmRpcRequestBody;
+
+  const network = ALLOWED_EVM_NETWORKS[networkId];
+  if (!network?.infura) {
+    return c.json({ error: "Infura not available for this network" }, 400);
+  }
+
+  const url = `https://${network.infura}.infura.io/v3/${c.env.INFURA_API_KEY}`;
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const status = response.status;
+      if (status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        if (retryAfter) c.header("Retry-After", retryAfter);
+        return c.json({ error: "EVM RPC rate limit exceeded" }, 429);
+      }
+      return c.json({ error: `EVM RPC error (HTTP ${status})` }, 502);
+    }
+
+    const data = await response.json();
+    return c.json(data);
+  } catch {
+    return c.json({ error: "Failed to connect to EVM RPC" }, 502);
+  }
+}
diff --git a/worker/src/routes/onfinalityRpc.ts b/worker/src/routes/onfinalityRpc.ts
new file mode 100644
index 00000000..c67d375c
--- /dev/null
+++ b/worker/src/routes/onfinalityRpc.ts
@@ -0,0 +1,43 @@
+import type { Context } from "hono";
+import type { BtcRpcRequestBody, Env } from "../types";
+
+const ONFINALITY_BTC_HOSTS: Record<string, string> = {
+  "bip122:000000000019d6689c085ae165831e93": "bitcoin.api.onfinality.io",
+  "bip122:000000000933ea01ad0ee984209779ba": "bitcoin-testnet.api.onfinality.io",
+};
+
+export async function btcOnfinalityHandler(c: Context<{ Bindings: Env }>) {
+  const networkId = c.req.param("networkId") ?? "";
+  const body = c.get("validatedBody" as never) as unknown as BtcRpcRequestBody;
+
+  const host = ONFINALITY_BTC_HOSTS[networkId];
+  if (!host) {
+    const allowed = Object.keys(ONFINALITY_BTC_HOSTS).join(", ");
+    return c.json({ error: `Invalid networkId. Allowed: ${allowed}` }, 400);
+  }
+
+  const url = `https://${host}/rpc?apikey=${c.env.ONFINALITY_BTC_API_KEY}`;
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const status = response.status;
+      if (status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        if (retryAfter) c.header("Retry-After", retryAfter);
+        return c.json({ error: "Bitcoin RPC rate limit exceeded" }, 429);
+      }
+      return c.json({ error: `Bitcoin RPC error (HTTP ${status})` }, 502);
+    }
+
+    const data = await response.json();
+    return c.json(data);
+  } catch {
+    return c.json({ error: "Failed to connect to Bitcoin RPC" }, 502);
+  }
+}
diff --git a/worker/src/types.ts b/worker/src/types.ts
index bcd82948..e3ae75ad 100644
--- a/worker/src/types.ts
+++ b/worker/src/types.ts
@@ -23,6 +23,166 @@ export interface EtherscanVerifyRequestBody {
 export interface Env {
   GROQ_API_KEY: string;
   ETHERSCAN_API_KEY: string;
+  ALCHEMY_API_KEY: string;
+  INFURA_API_KEY: string;
+  DRPC_API_KEY: string;
+  ONFINALITY_BTC_API_KEY: string;
+  ANKR_API_KEY: string;
   ALLOWED_ORIGINS: string;
   GROQ_MODEL: string;
 }
+
+// ── Beacon types ──────────────────────────────────────────────────────────────
+
+/** Beacon API is only supported on these networks */
+export const ALLOWED_BEACON_NETWORKS: Record<string, string> = {
+  "eip155:1": "eth-mainnet",
+  "eip155:11155111": "eth-sepolia",
+};
+
+// ── Bitcoin types ─────────────────────────────────────────────────────────────
+
+export const ALLOWED_BTC_METHODS = [
+  "getblock",
+  "getrawtransaction",
+  "getblockchaininfo",
+  "getblockcount",
+  "getblockhash",
+  "getrawmempool",
+  "getmempoolinfo",
+  "getmempoolentry",
+  "estimatesmartfee",
+  "gettxout",
+  "scantxoutset",
+  "getblockheader",
+  "decoderawtransaction",
+  "listunspent",
+  "validateaddress",
+  "getblockstats",
+] as const;
+
+export interface BtcRpcRequestBody {
+  jsonrpc: string;
+  method: string;
+  params: unknown[];
+  id: unknown;
+}
+
+// ── EVM types ─────────────────────────────────────────────────────────────────
+
+/** Read-only EVM methods the explorer is allowed to call through the proxy */
+export const ALLOWED_EVM_METHODS = [
+  // ── Standard read methods ───────────────────────────────────────────────────
+  "web3_clientVersion",
+  "web3_sha3",
+  "net_version",
+  "net_listening",
+  "net_peerCount",
+  "eth_blockNumber",
+  "eth_chainId",
+  "eth_gasPrice",
+  "eth_maxPriorityFeePerGas",
+  "eth_feeHistory",
+  "eth_syncing",
+  "eth_protocolVersion",
+  "eth_getBalance",
+  "eth_getCode",
+  "eth_getStorageAt",
+  "eth_getTransactionCount",
+  "eth_getProof",
+  "eth_call",
+  "eth_estimateGas",
+  "eth_createAccessList",
+  "eth_getLogs",
+  // ── Block methods ───────────────────────────────────────────────────────────
+  "eth_getBlockByNumber",
+  "eth_getBlockByHash",
+  "eth_getBlockTransactionCountByHash",
+  "eth_getBlockTransactionCountByNumber",
+  "eth_getBlockReceipts",
+  "eth_getUncleCountByBlockHash",
+  "eth_getUncleCountByBlockNumber",
+  "eth_getUncleByBlockHashAndIndex",
+  "eth_getUncleByBlockNumberAndIndex",
+  // ── Transaction methods ─────────────────────────────────────────────────────
+  "eth_getTransactionByHash",
+  "eth_getTransactionByBlockHashAndIndex",
+  "eth_getTransactionByBlockNumberAndIndex",
+  "eth_getTransactionReceipt",
+  "eth_getTransactionBySenderAndNonce",
+  // ── Debug / trace methods ───────────────────────────────────────────────────
+  "debug_traceTransaction",
+  "debug_traceCall",
+  "debug_traceBlockByHash",
+  "debug_traceBlockByNumber",
+  "trace_transaction",
+  "trace_block",
+  "trace_call",
+  "trace_filter",
+  "trace_replayBlockTransactions",
+  "trace_replayTransaction",
+  // ── Arbitrum-specific ───────────────────────────────────────────────────────
+  "arbtrace_transaction",
+  "arbtrace_block",
+  "arbtrace_call",
+  "arbtrace_callMany",
+  // ── BNB-specific ────────────────────────────────────────────────────────────
+  "eth_getHeaderByNumber",
+  "eth_getTransactionsByBlockNumber",
+  "eth_getTransactionDataAndReceipt",
+  "eth_getFinalizedBlock",
+  "eth_getFinalizedHeader",
+  "eth_getBlobSidecars",
+  "eth_getBlobSidecarByTxHash",
+  "eth_health",
+  // ── Avalanche-specific ──────────────────────────────────────────────────────
+  "eth_baseFee",
+  "eth_getChainConfig",
+] as const;
+
+/** Maps CAIP-2 networkId → { alchemy slug, infura slug, drpc slug, ankr slug } */
+export const ALLOWED_EVM_NETWORKS: Record<
+  string,
+  { alchemy: string; infura?: string; drpc: string; ankr: string }
+> = {
+  "eip155:1": { alchemy: "eth-mainnet", infura: "mainnet", drpc: "ethereum", ankr: "eth" },
+  "eip155:11155111": {
+    alchemy: "eth-sepolia",
+    infura: "sepolia",
+    drpc: "sepolia",
+    ankr: "eth_sepolia",
+  },
+  "eip155:42161": {
+    alchemy: "arb-mainnet",
+    infura: "arbitrum-mainnet",
+    drpc: "arbitrum",
+    ankr: "arbitrum",
+  },
+  "eip155:10": {
+    alchemy: "opt-mainnet",
+    infura: "optimism-mainnet",
+    drpc: "optimism",
+    ankr: "optimism",
+  },
+  "eip155:8453": { alchemy: "base-mainnet", infura: "base-mainnet", drpc: "base", ankr: "base" },
+  "eip155:137": {
+    alchemy: "polygon-mainnet",
+    infura: "polygon-mainnet",
+    drpc: "polygon",
+    ankr: "polygon",
+  },
+  "eip155:56": { alchemy: "bnb-mainnet", drpc: "bsc", ankr: "bsc" },
+  "eip155:43114": {
+    alchemy: "avax-mainnet",
+    infura: "avalanche-mainnet",
+    drpc: "avalanche",
+    ankr: "avalanche",
+  },
+};
+
+export interface EvmRpcRequestBody {
+  jsonrpc: string;
+  method: string;
+  params: unknown[];
+  id: unknown;
+}
diff --git a/worker/wrangler.toml b/worker/wrangler.toml
index 076fb635..5bcdb8da 100644
--- a/worker/wrangler.toml
+++ b/worker/wrangler.toml
@@ -1,4 +1,4 @@
-name = "openscan-groq-ai-proxy"
+name = "openscan-worker-proxy"
 main = "src/index.ts"
 compatibility_date = "2024-12-01"
 
@@ -9,4 +9,9 @@ GROQ_MODEL = "groq/compound"
 # Secrets — set via `wrangler secret put <NAME>`
 # GROQ_API_KEY      — Groq AI API key for /ai/analyze
 # ETHERSCAN_API_KEY  — Etherscan V2 API key for /etherscan/verify
+# ALCHEMY_API_KEY   — Alchemy API key for /beacon/*, /btc/alchemy, /evm/alchemy/*
+# INFURA_API_KEY    — Infura API key for /evm/infura/*
+# DRPC_API_KEY      — dRPC API key for /evm/drpc/*, /btc/drpc
+# ONFINALITY_BTC_API_KEY — OnFinality API key for /btc/onfinality/*
+# ANKR_API_KEY      — Ankr API key for /evm/ankr/*, /btc/ankr