feat(filecoin): filecoin chain and rpc support

Updates the supported chains to support filecoin and filecoin
calibration. Because of the JWT authentication of Glif the rpcFactory
and evmClient builder were imported from the hypercerts-indexer.

Test were created and updated accordingly

Author: bitbeckers

.github/workflows/ci-test-unit.yml

@@ -19,6 +19,7 @@ jobs:
       ALCHEMY_API_KEY: ${{ secrets.ALCHEMY_API_KEY }}
       DRPC_API_KEY: "test"
       INFURA_API_KEY: "test"
+      FILECOIN_API_KEY: "test"
 
       INDEXER_ENVIRONMENT: "test"
 

eslint.config.js

@@ -4,4 +4,9 @@ import tseslint from "typescript-eslint";
 export default tseslint.config(
   eslint.configs.recommended,
   ...tseslint.configs.strict,
+  {
+    rules: {
+      "@typescript-eslint/no-extraneous-class": "off",
+    },
+  },
 );

package.json

@@ -28,9 +28,9 @@
   "dependencies": {
     "@graphql-tools/merge": "^9.0.3",
     "@graphql-yoga/plugin-response-cache": "^3.5.0",
-    "@hypercerts-org/contracts": "2.0.0-alpha.11",
+    "@hypercerts-org/contracts": "2.0.0-alpha.12",
     "@hypercerts-org/marketplace-sdk": "0.3.37",
-    "@hypercerts-org/sdk": "2.3.0",
+    "@hypercerts-org/sdk": "2.4.0",
     "@ipld/car": "^5.2.5",
     "@openzeppelin/merkle-tree": "^1.0.5",
     "@safe-global/api-kit": "^2.5.4",

pnpm-lock.yaml

@@ -0,0 +1,42 @@
+import {
+  indexerEnvironment as environment,
+  Environment,
+} from "../utils/constants.js";
+import { Chain } from "viem";
+import {
+  arbitrum,
+  arbitrumSepolia,
+  base,
+  baseSepolia,
+  celo,
+  filecoin,
+  filecoinCalibration,
+  optimism,
+  sepolia,
+} from "viem/chains";
+
+export class ChainFactory {
+  static getChain(chainId: number): Chain {
+    const chains: Record<number, Chain> = {
+      10: optimism,
+      314: filecoin,
+      8453: base,
+      42161: arbitrum,
+      42220: celo,
+      84532: baseSepolia,
+      314159: filecoinCalibration,
+      421614: arbitrumSepolia,
+      11155111: sepolia,
+    };
+
+    const chain = chains[chainId];
+    if (!chain) throw new Error(`Unsupported chain ID: ${chainId}`);
+    return chain;
+  }
+
+  static getSupportedChains(): number[] {
+    return environment === Environment.TEST
+      ? [84532, 314159, 421614, 11155111]
+      : [10, 8453, 42220, 42161, 314];
+  }
+}

src/client/chainFactory.ts

@@ -0,0 +1,121 @@
+import {
+  alchemyApiKey,
+  drpcApiPkey,
+  infuraApiKey,
+} from "../utils/constants.js";
+import { PublicClient, createPublicClient, fallback } from "viem";
+import { ChainFactory } from "./chainFactory.js";
+import { RpcClientFactory } from "./rpcClientFactory.js";
+import { Eip1193Provider, JsonRpcProvider } from "ethers";
+
+interface RpcProvider {
+  getUrl(chainId: number): string | undefined;
+}
+
+class AlchemyProvider implements RpcProvider {
+  getUrl(chainId: number): string | undefined {
+    const urls: Record<number, string> = {
+      10: `https://opt-mainnet.g.alchemy.com/v2/${alchemyApiKey}`,
+      8453: `https://base-mainnet.g.alchemy.com/v2/${alchemyApiKey}`,
+      42161: `https://arb-mainnet.g.alchemy.com/v2/${alchemyApiKey}`,
+      421614: `https://arb-sepolia.g.alchemy.com/v2/${alchemyApiKey}`,
+      84532: `https://base-sepolia.g.alchemy.com/v2/${alchemyApiKey}`,
+      11155111: `https://eth-sepolia.g.alchemy.com/v2/${alchemyApiKey}`,
+    };
+    return urls[chainId];
+  }
+}
+
+class InfuraProvider implements RpcProvider {
+  getUrl(chainId: number): string | undefined {
+    const urls: Record<number, string> = {
+      10: `https://optimism-mainnet.infura.io/v3/${infuraApiKey}`,
+      42220: `https://celo-mainnet.infura.io/v3/${infuraApiKey}`,
+      42161: `https://arbitrum-mainnet.infura.io/v3/${infuraApiKey}`,
+      421614: `https://arbitrum-sepolia.infura.io/v3/${infuraApiKey}`,
+    };
+    return urls[chainId];
+  }
+}
+
+class DrpcProvider implements RpcProvider {
+  getUrl(chainId: number): string | undefined {
+    const networks: Record<number, string> = {
+      10: "optimism",
+      8453: "base",
+      42220: "celo",
+      42161: "arbitrum",
+      421614: "arbitrum-sepolia",
+    };
+    const network = networks[chainId];
+    return network
+      ? `https://lb.drpc.org/ogrpc?network=${network}&dkey=${drpcApiPkey}`
+      : undefined;
+  }
+}
+
+class GlifProvider implements RpcProvider {
+  getUrl(chainId: number): string | undefined {
+    const urls: Record<number, string> = {
+      314: `https://node.glif.io/space07/lotus/rpc/v1`,
+      314159: `https://calibration.node.glif.io/archive/lotus/rpc/v1`,
+    };
+    return urls[chainId];
+  }
+}
+
+export class EvmClientFactory {
+  private static readonly providers: RpcProvider[] = [
+    new AlchemyProvider(),
+    new InfuraProvider(),
+    new DrpcProvider(),
+    new GlifProvider(),
+  ];
+
+  static createViemClient(chainId: number): PublicClient {
+    const urls = EvmClientFactory.getAllAvailableUrls(chainId);
+    if (urls.length === 0)
+      throw new Error(`No RPC URL available for chain ${chainId}`);
+
+    const transports = urls.map((url) =>
+      RpcClientFactory.createViemTransport(chainId, url),
+    );
+
+    return createPublicClient({
+      chain: ChainFactory.getChain(chainId),
+      transport: fallback(transports),
+    });
+  }
+
+  static createEthersClient(chainId: number): JsonRpcProvider {
+    const url = EvmClientFactory.getFirstAvailableUrl(chainId);
+    if (!url) throw new Error(`No RPC URL available for chain ${chainId}`);
+    return RpcClientFactory.createEthersJsonRpcProvider(chainId, url);
+  }
+
+  static createEip1193Client(chainId: number): Eip1193Provider {
+    const url = EvmClientFactory.getFirstAvailableUrl(chainId);
+    if (!url) throw new Error(`No RPC URL available for chain ${chainId}`);
+    return RpcClientFactory.createEip1193Provider(chainId, url);
+  }
+
+  static getAllAvailableUrls(chainId: number): string[] {
+    return EvmClientFactory.providers
+      .map((provider) => provider.getUrl(chainId))
+      .filter((url): url is string => url !== undefined);
+  }
+
+  // Keep this for backward compatibility
+  static getFirstAvailableUrl(chainId: number): string | undefined {
+    return EvmClientFactory.getAllAvailableUrls(chainId)[0];
+  }
+}
+
+export const getRpcUrl = (chainId: number): string => {
+  const url = EvmClientFactory.getFirstAvailableUrl(chainId);
+  if (!url) throw new Error(`No RPC URL available for chain ${chainId}`);
+  return url;
+};
+
+// Public API
+export const getSupportedChains = ChainFactory.getSupportedChains;

src/client/evmClient.ts

@@ -0,0 +1,81 @@
+import { http, Transport } from "viem";
+import { CustomEthersJsonRpcProvider } from "../lib/rpcProviders/customEthersJsonRpcProvider.js";
+import { filecoinApiKey } from "../utils/constants.js";
+import { ChainFactory } from "./chainFactory.js";
+import { CustomEip1193Provider } from "../lib/rpcProviders/customEthers1193RpcProvider.js";
+
+interface RpcConfig {
+  url: string;
+  headers?: Record<string, string>;
+  timeout?: number;
+}
+
+// Chain-specific RPC configuration factory
+class RpcConfigFactory {
+  private static readonly DEFAULT_TIMEOUT = 20_000;
+
+  static getConfig(chainId: number, url: string): RpcConfig {
+    const baseConfig: RpcConfig = {
+      url,
+      timeout: this.DEFAULT_TIMEOUT,
+    };
+
+    // Chain-specific configurations
+    switch (chainId) {
+      case 314:
+      case 314159:
+        return {
+          ...baseConfig,
+          headers: {
+            Authorization: `Bearer ${filecoinApiKey}`,
+          },
+        };
+      default:
+        return baseConfig;
+    }
+  }
+}
+
+// Unified client factory for both Viem and Chainsauce clients
+export class RpcClientFactory {
+  // Creates a Viem transport
+  static createViemTransport(chainId: number, url: string): Transport {
+    const config = RpcConfigFactory.getConfig(chainId, url);
+
+    const httpConfig: Parameters<typeof http>[1] = {
+      timeout: config.timeout,
+    };
+
+    if (config.headers) {
+      httpConfig.fetchOptions = {
+        headers: config.headers,
+      };
+    }
+
+    return http(config.url, httpConfig);
+  }
+
+  static createEthersJsonRpcProvider(chainId: number, url: string) {
+    const config = RpcConfigFactory.getConfig(chainId, url);
+    const chain = ChainFactory.getChain(chainId);
+    const network = {
+      chainId: chain.id,
+      name: chain.name,
+      ensAddress: chain.contracts?.ensRegistry?.address,
+    };
+
+    return new CustomEthersJsonRpcProvider({
+      url: config.url,
+      config: { headers: config.headers },
+      network,
+    });
+  }
+
+  static createEip1193Provider(chainId: number, url: string) {
+    const config = RpcConfigFactory.getConfig(chainId, url);
+    return new CustomEip1193Provider({
+      url: config.url,
+      config: { headers: config.headers },
+    });
+  }
+}

src/client/rpcClientFactory.ts

@@ -9,19 +9,19 @@ import {
   SuccessResponse,
   Tags,
 } from "tsoa";
+import { isAddress } from "viem";
+import { z } from "zod";
+import { EvmClientFactory } from "../client/evmClient.js";
+import { SupabaseDataService } from "../services/SupabaseDataService.js";
 import type {
-  BlueprintResponse,
+  BaseResponse,
   BlueprintCreateRequest,
   BlueprintDeleteRequest,
   BlueprintQueueMintRequest,
-  BaseResponse,
+  BlueprintResponse,
 } from "../types/api.js";
-import { z } from "zod";
-import { SupabaseDataService } from "../services/SupabaseDataService.js";
-import { verifyAuthSignedData } from "../utils/verifyAuthSignedData.js";
-import { isAddress } from "viem";
 import { Json } from "../types/supabaseData.js";
-import { getEvmClient } from "../utils/getRpcUrl.js";
+import { verifyAuthSignedData } from "../utils/verifyAuthSignedData.js";
 import { waitForTxThenMintBlueprint } from "../utils/waitForTxThenMintBlueprint.js";
 
 @Route("v1/blueprints")
@@ -367,7 +367,7 @@ export class BlueprintController extends Controller {
       };
     }
 
-    const client = getEvmClient(chain_id);
+    const client = EvmClientFactory.createViemClient(chain_id);
     const transaction = await client.getTransaction({
       hash: tx_hash as `0x${string}`,
     });

src/controllers/BlueprintController.ts

@@ -3,7 +3,7 @@ import {
   HypercertExchangeClient,
   utils,
 } from "@hypercerts-org/marketplace-sdk";
-import { ethers, verifyTypedData } from "ethers";
+import { verifyTypedData } from "ethers";
 import {
   Body,
   Controller,
@@ -17,12 +17,12 @@ import {
 import { z } from "zod";
 
 import { isAddress, verifyMessage } from "viem";
+import { EvmClientFactory } from "../client/evmClient.js";
 import { SupabaseDataService } from "../services/SupabaseDataService.js";
+import { BaseResponse } from "../types/api.js";
 import { getFractionsById } from "../utils/getFractionsById.js";
-import { getRpcUrl } from "../utils/getRpcUrl.js";
 import { isParsableToBigInt } from "../utils/isParsableToBigInt.js";
 import { getHypercertTokenId } from "../utils/tokenIds.js";
-import { BaseResponse } from "../types/api.js";
 
 export interface CreateOrderRequest {
   signature: string;
@@ -148,7 +148,7 @@ export class MarketplaceController extends Controller {
     const hec = new HypercertExchangeClient(
       chainId,
       // @ts-expect-error Typing issue with provider
-      new ethers.JsonRpcProvider(getRpcUrl(chainId)),
+      EvmClientFactory.createEthersClient(chainId),
     );
     const typedData = hec.getTypedDataDomain();
 

src/controllers/MarketplaceController.ts

@@ -0,0 +1,48 @@
+import { Eip1193Provider, FetchRequest } from "ethers";
+
+interface CustomEip1193Config {
+  headers?: Record<string, string>;
+}
+
+interface CustomEip1193ProviderOptions {
+  url: string | FetchRequest;
+  config?: CustomEip1193Config;
+}
+
+export class CustomEip1193Provider implements Eip1193Provider {
+  private fetchRequest: FetchRequest;
+
+  constructor({ url, config }: CustomEip1193ProviderOptions) {
+    if (typeof url === "string") {
+      url = new FetchRequest(url);
+    }
+    this.fetchRequest = url.clone();
+
+    if (config?.headers) {
+      Object.entries(config.headers).forEach(([key, value]) => {
+        this.fetchRequest.setHeader(key, value);
+      });
+    }
+  }
+
+  async request(args: {
+    method: string;
+    params?: Array<unknown>;
+  }): Promise<unknown> {
+    this.fetchRequest.method = "POST";
+    this.fetchRequest.body = JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: args.method,
+      params: args.params || [],
+    });
+
+    const response = await this.fetchRequest.send();
+
+    const result = JSON.parse(response.bodyText);
+    if (result.error) {
+      throw new Error(result.error.message || "RPC Error");
+    }
+    return result.result;
+  }
+}