feat: implements BlockNumberService

packages/blocknumber/src/exceptions/chainWithoutProvider.ts

@@ -0,0 +1,9 @@
+import { Caip2ChainId } from "../types.js";
+
+export class ChainWithoutProvider extends Error {
+    constructor(chainId: Caip2ChainId) {
+        super(`Chain ${chainId} has no provider defined.`);
+
+        this.name = "ChainWithoutProvider";
+    }
+}

packages/blocknumber/src/exceptions/emptyRpcUrls.ts

@@ -0,0 +1,7 @@
+export class EmptyRpcUrls extends Error {
+    constructor() {
+        super(`At least one chain with its RPC endpoint must be defined.`);
+
+        this.name = "EmptyRpcUrls";
+    }
+}

packages/blocknumber/src/exceptions/index.ts

@@ -1,7 +1,10 @@
+export * from "./chainWithoutProvider.js";
+export * from "./emptyRpcUrls.js";
 export * from "./invalidChain.js";
 export * from "./invalidTimestamp.js";
 export * from "./lastBlockEpoch.js";
 export * from "./timestampNotFound.js";
 export * from "./unexpectedSearchRange.js";
 export * from "./unsupportedBlockNumber.js";
 export * from "./unsupportedBlockTimestamps.js";
+export * from "./unsupportedChain.js";

packages/blocknumber/src/exceptions/unsupportedChain.ts

@@ -0,0 +1,9 @@
+import { Caip2ChainId } from "../types.js";
+
+export class UnsupportedChain extends Error {
+    constructor(chainId: Caip2ChainId) {
+        super(`Chain ${chainId} is not supported.`);
+
+        this.name = "UnsupportedChain";
+    }
+}

packages/blocknumber/src/providers/evmBlockNumberProvider.ts

@@ -1,5 +1,5 @@
 import { ILogger } from "@ebo-agent/shared";
-import { Block, PublicClient } from "viem";
+import { Block, FallbackTransport, HttpTransport, PublicClient } from "viem";
 
 import {
     InvalidTimestamp,
@@ -9,7 +9,6 @@ import {
     UnsupportedBlockNumber,
     UnsupportedBlockTimestamps,
 } from "../exceptions/index.js";
-import logger from "../utils/logger.js";
 import { BlockNumberProvider } from "./blockNumberProvider.js";
 
 const BINARY_SEARCH_BLOCKS_LOOKBACK = 10_000n;
@@ -31,7 +30,7 @@ interface SearchConfig {
 }
 
 export class EvmBlockNumberProvider implements BlockNumberProvider {
-    private client: PublicClient;
+    private client: PublicClient<FallbackTransport<HttpTransport[]>>;
     private searchConfig: SearchConfig;
     private firstBlock: Block | null;
 
@@ -45,7 +44,7 @@ export class EvmBlockNumberProvider implements BlockNumberProvider {
      *  while scanning blocks backwards during lower bound search. Defaults to 2.
      */
     constructor(
-        client: PublicClient,
+        client: PublicClient<FallbackTransport<HttpTransport[]>>,
         searchConfig: { blocksLookback?: bigint; deltaMultiplier?: bigint },
         private logger: ILogger,
     ) {
@@ -201,15 +200,15 @@ export class EvmBlockNumberProvider implements BlockNumberProvider {
 
         if (low > high) throw new UnexpectedSearchRange(low, high);
 
-        logger.debug(`Starting block binary search for timestamp ${timestamp}...`);
+        this.logger.debug(`Starting block binary search for timestamp ${timestamp}...`);
 
         while (low <= high) {
             currentBlockNumber = (high + low) / 2n;
 
             const currentBlock = await this.client.getBlock({ blockNumber: currentBlockNumber });
             const nextBlock = await this.client.getBlock({ blockNumber: currentBlockNumber + 1n });
 
-            logger.debug(
+            this.logger.debug(
                 `Analyzing block number #${currentBlock.number} with timestamp ${currentBlock.timestamp}`,
             );
 
@@ -223,7 +222,7 @@ export class EvmBlockNumberProvider implements BlockNumberProvider {
                 currentBlock.timestamp <= timestamp && nextBlock.timestamp > timestamp;
 
             if (blockContainsTimestamp) {
-                logger.debug(`Block #${currentBlock.number} contains timestamp.`);
+                this.logger.debug(`Block #${currentBlock.number} contains timestamp.`);
 
                 return currentBlock.number;
             } else if (currentBlock.timestamp <= timestamp) {

packages/blocknumber/src/services/blockNumberService.ts

@@ -0,0 +1,100 @@
+import { Logger, supportedChains } from "@ebo-agent/shared";
+import {
+    createPublicClient,
+    fallback,
+    FallbackTransport,
+    http,
+    HttpTransport,
+    PublicClient,
+} from "viem";
+
+import { ChainWithoutProvider, EmptyRpcUrls, UnsupportedChain } from "../exceptions/index.js";
+import { BlockNumberProvider } from "../providers/blockNumberProvider.js";
+import { EvmBlockNumberProvider } from "../providers/evmBlockNumberProvider.js";
+import { Caip2ChainId } from "../types.js";
+import { Caip2 } from "../utils/index.js";
+
+type RpcUrl = NonNullable<Parameters<typeof http>[0]>;
+
+const DEFAULT_PROVIDER_CONFIG = {
+    blocksLookback: 10_000n,
+    deltaMultiplier: 2n,
+};
+
+export class BlockNumberService {
+    private blockNumberProviders: Map<Caip2ChainId, BlockNumberProvider>;
+
+    constructor(chainRpcUrls: Map<Caip2ChainId, RpcUrl[]>) {
+        this.blockNumberProviders = this.buildBlockNumberProviders(chainRpcUrls);
+    }
+
+    public async getEpochBlockNumbers(timestamp: number, chains: Caip2ChainId[]) {
+        const epochBlockNumbers = await Promise.all(
+            chains.map(async (chainId) => {
+                const provider = this.blockNumberProviders.get(chainId);
+
+                if (!provider) throw new ChainWithoutProvider(chainId);
+
+                const blockNumber = await provider.getEpochBlockNumber(timestamp);
+
+                return [chainId, blockNumber] as [Caip2ChainId, bigint];
+            }),
+        );
+
+        const e = epochBlockNumbers.filter(
+            (entry): entry is [Caip2ChainId, bigint] => entry !== null,
+        );
+
+        return new Map(e);
+    }
+
+    private buildBlockNumberProviders(chainRpcUrls: Map<Caip2ChainId, RpcUrl[]>) {
+        if (chainRpcUrls.size == 0) throw new EmptyRpcUrls();
+
+        const supportedChainIds = this.getSupportedChainIds(supportedChains);
+        const providers = new Map<Caip2ChainId, BlockNumberProvider>();
+
+        for (const [chainId, urls] of chainRpcUrls) {
+            if (!supportedChainIds.includes(chainId)) throw new UnsupportedChain(chainId);
+
+            const client = createPublicClient({
+                transport: fallback(urls.map((url) => http(url))),
+            });
+
+            const provider = BlockNumberService.buildProvider(chainId, client);
+
+            if (!provider) throw new ChainWithoutProvider(chainId);
+
+            providers.set(chainId, provider);
+        }
+
+        return providers;
+    }
+
+    private getSupportedChainIds(chainsConfig: typeof supportedChains) {
+        const namespacesChains = Object.values(chainsConfig);
+
+        return namespacesChains.reduce((acc, namespaceChains) => {
+            return [...acc, ...Object.values(namespaceChains.chains)];
+        }, [] as string[]);
+    }
+
+    public static buildProvider(
+        chainId: Caip2ChainId,
+        client: PublicClient<FallbackTransport<HttpTransport[]>>,
+    ) {
+        const chainNamespace = Caip2.getNamespace(chainId);
+
+        switch (chainNamespace) {
+            case supportedChains.evm.namespace:
+                return new EvmBlockNumberProvider(
+                    client,
+                    DEFAULT_PROVIDER_CONFIG,
+                    Logger.getInstance(), // Should we drop this arg?
+                );
+
+            default:
+                throw new UnsupportedChain(chainId);
+        }
+    }
+}

packages/blocknumber/src/services/index.ts

@@ -0,0 +1 @@
+export * from "./blockNumberService.js";

packages/blocknumber/src/types.ts

@@ -0,0 +1 @@
+export type Caip2ChainId = `${string}:${string}`;

packages/blocknumber/src/utils/chainId.ts → packages/blocknumber/src/utils/caip/caip2.ts

@@ -1,41 +1,19 @@
 // Based on https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-2.md
 
-import { InvalidChainId } from "../exceptions/invalidChain.js";
-
-type ChainNamespace = string;
-type ChainReference = string;
-
-interface ChainIdParams {
-    namespace: ChainNamespace;
-    reference: ChainReference;
-}
+import { InvalidChainId } from "../../exceptions/invalidChain.js";
+import { Caip2ChainId } from "../../types.js";
 
 const NAMESPACE_FORMAT = /^[-a-z0-9]{3,8}$/;
 const REFERENCE_FORMAT = /^[-_a-zA-Z0-9]{1,32}$/;
 
-export class ChainId {
-    private namespace: string;
-    private reference: string;
-
-    /**
-     * Creates a validated CAIP-2 compliant chain ID.
-     *
-     * @param chainId a CAIP-2 compliant string.
-     */
-    constructor(chainId: string) {
-        const params = ChainId.parse(chainId);
-
-        this.namespace = params.namespace;
-        this.reference = params.reference;
-    }
-
+export class Caip2 {
     /**
      * Parses a CAIP-2 compliant string.
      *
      * @param chainId {string} a CAIP-2 compliant string
-     * @returns an object containing the namespace and the reference of the chain id
+     * @returns the CAIP-2 validated chain id string
      */
-    public static parse(chainId: string): ChainIdParams {
+    public static validateChainId(chainId: string): chainId is Caip2ChainId {
         const elements = chainId.split(":");
 
         if (elements.length !== 2) {
@@ -54,13 +32,14 @@ export class ChainId {
         const isValidReference = REFERENCE_FORMAT.test(reference);
         if (!isValidReference) throw new InvalidChainId("Chain ID reference is not valid.");
 
-        return {
-            namespace,
-            reference,
-        };
+        return true;
     }
 
-    public toString() {
-        return `${this.namespace}:${this.reference}`;
+    public static getNamespace(chainId: string | Caip2ChainId) {
+        this.validateChainId(chainId);
+
+        const namespace = chainId.split(":")[0] as string;
+
+        return namespace;
     }
 }

packages/blocknumber/src/utils/caip/index.ts

@@ -0,0 +1 @@
+export * from "./caip2.js";

packages/blocknumber/src/utils/index.ts

@@ -1,2 +1 @@
-export * from "./chainId.js";
-export * from "./logger.js";
+export * from "./caip/caip2.js";

packages/blocknumber/test/providers/evmBlockNumberProvider.spec.ts

@@ -1,3 +1,4 @@
+import { Logger } from "@ebo-agent/shared";
 import { Block, createPublicClient, GetBlockParameters, http } from "viem";
 import { mainnet } from "viem/chains";
 import { describe, expect, it, vi } from "vitest";
@@ -13,6 +14,7 @@ import { EvmBlockNumberProvider } from "../../src/providers/evmBlockNumberProvid
 describe("EvmBlockNumberProvider", () => {
     describe("getEpochBlockNumber", () => {
         const searchConfig = { blocksLookback: 2n, deltaMultiplier: 2n };
+        const logger = Logger.getInstance();
         let evmProvider: EvmBlockNumberProvider;
 
         it("returns the first of two consecutive blocks when their timestamp contains the searched timestamp", async () => {
@@ -21,7 +23,7 @@ describe("EvmBlockNumberProvider", () => {
             const endTimestamp = Date.UTC(2024, 1, 11, 0, 0, 0, 0);
             const rpcProvider = mockRpcProvider(blockNumber, startTimestamp, endTimestamp);
 
-            evmProvider = new EvmBlockNumberProvider(rpcProvider, searchConfig);
+            evmProvider = new EvmBlockNumberProvider(rpcProvider, searchConfig, logger);
 
             const day5 = Date.UTC(2024, 1, 5, 2, 0, 0, 0);
             const epochBlockNumber = await evmProvider.getEpochBlockNumber(day5);
@@ -35,7 +37,7 @@ describe("EvmBlockNumberProvider", () => {
             const endTimestamp = Date.UTC(2024, 1, 1, 0, 0, 11, 0);
             const rpcProvider = mockRpcProvider(lastBlockNumber, startTimestamp, endTimestamp);
 
-            evmProvider = new EvmBlockNumberProvider(rpcProvider, searchConfig);
+            evmProvider = new EvmBlockNumberProvider(rpcProvider, searchConfig, logger);
 
             const exactDay5 = Date.UTC(2024, 1, 1, 0, 0, 5, 0);
             const epochBlockNumber = await evmProvider.getEpochBlockNumber(exactDay5);
@@ -49,7 +51,7 @@ describe("EvmBlockNumberProvider", () => {
             const endTimestamp = Date.UTC(2024, 1, 1, 0, 0, 11, 0);
             const rpcProvider = mockRpcProvider(lastBlockNumber, startTimestamp, endTimestamp);
 
-            evmProvider = new EvmBlockNumberProvider(rpcProvider, searchConfig);
+            evmProvider = new EvmBlockNumberProvider(rpcProvider, searchConfig, logger);
 
             const futureTimestamp = Date.UTC(2025, 1, 1, 0, 0, 0, 0);
 
@@ -64,7 +66,7 @@ describe("EvmBlockNumberProvider", () => {
             const endTimestamp = Date.UTC(2024, 1, 1, 0, 0, 11, 0);
             const rpcProvider = mockRpcProvider(lastBlockNumber, startTimestamp, endTimestamp);
 
-            evmProvider = new EvmBlockNumberProvider(rpcProvider, searchConfig);
+            evmProvider = new EvmBlockNumberProvider(rpcProvider, searchConfig, logger);
 
             const futureTimestamp = Date.UTC(1970, 1, 1, 0, 0, 0, 0);
 
@@ -84,7 +86,7 @@ describe("EvmBlockNumberProvider", () => {
                 { number: 4n, timestamp: afterTimestamp },
             ]);
 
-            evmProvider = new EvmBlockNumberProvider(rpcProvider, searchConfig);
+            evmProvider = new EvmBlockNumberProvider(rpcProvider, searchConfig, logger);
 
             expect(evmProvider.getEpochBlockNumber(Number(timestamp))).rejects.toBeInstanceOf(
                 UnsupportedBlockTimestamps,
@@ -97,7 +99,7 @@ describe("EvmBlockNumberProvider", () => {
                 { number: null, timestamp: BigInt(timestamp) },
             ]);
 
-            evmProvider = new EvmBlockNumberProvider(rpcProvider, searchConfig);
+            evmProvider = new EvmBlockNumberProvider(rpcProvider, searchConfig, logger);
 
             expect(evmProvider.getEpochBlockNumber(Number(timestamp))).rejects.toBeInstanceOf(
                 UnsupportedBlockNumber,
@@ -109,7 +111,7 @@ describe("EvmBlockNumberProvider", () => {
 
             client.getBlock = vi.fn().mockRejectedValue(null);
 
-            evmProvider = new EvmBlockNumberProvider(client, searchConfig);
+            evmProvider = new EvmBlockNumberProvider(client, searchConfig, logger);
             const timestamp = Date.UTC(2024, 1, 1, 0, 0, 0, 0);
 
             expect(evmProvider.getEpochBlockNumber(timestamp)).rejects.toBeDefined();