unify balancer and sushi routers

package.json

@@ -36,10 +36,11 @@
         "lint": "eslint ./src ./test ./rain-solver.js",
         "lint-fix": "eslint ./src ./test ./rain-solver.js --fix",
         "rain-solver": "ts-node rain-solver",
-        "build": "tsc",
+        "build": "npm run check && tsc",
         "vitest:logger": "vitest run ./src/logger/index.test.ts --disableConsoleIntercept",
-        "vitest": "npm run vitest:logger && vitest run --exclude ./src/logger/index.test.ts",
-        "sweep": "ts-node ./scripts/sweep.ts"
+        "vitest": "npm run check && npm run vitest:logger && vitest run --exclude ./src/logger/index.test.ts",
+        "sweep": "ts-node ./scripts/sweep.ts",
+        "check": "tsc ./src/**/*.ts --noEmit --strict --esModuleInterop -m commonjs -t es2022 --lib es6 --lib es2022 -d --skipLibCheck"
     },
     "dependencies": {
         "@balancer/sdk": "^4.5.2",

scripts/sweep.ts

@@ -1,16 +1,17 @@
 /* eslint-disable no-console */
 import assert from "assert";
+import { ChainId } from "sushi";
 import { Command } from "commander";
 import { createPublicClient } from "viem";
 import { AppOptions } from "../src/config";
-import { ChainId, RainDataFetcher } from "sushi";
 import { sleep, TokenDetails } from "../src/common";
 import { getChainConfig } from "../src/state/chain";
 import { rainSolverTransport, RpcState } from "../src/rpc";
 import { WalletConfig, WalletManager } from "../src/wallet";
 import { SharedState, SharedStateConfig } from "../src/state";
 import { OrderManager, OrderManagerConfig } from "../src/order";
 import { SubgraphConfig, SubgraphManager } from "../src/subgraph";
+import { RainSolverRouter } from "../src/router/router";
 
 /**
  * Command-line interface for the sweep script
@@ -116,14 +117,24 @@ export async function sweepFunds(
         chain: chainConfig,
         transport: rainSolverTransport(rpcState, rainSolverTransportConfig),
     });
-    const dataFetcher = await RainDataFetcher.init(chainConfig.id as ChainId, client);
+    const routerResult = await RainSolverRouter.create({
+        chainId,
+        client,
+        sushiRouterConfig: {
+            sushiRouteProcessor4Address: chainConfig.routeProcessors["4"] as `0x${string}`,
+        },
+    });
+    if (routerResult.isErr()) {
+        throw routerResult.error;
+    }
 
     // start state
     const stateConfig: SharedStateConfig = {
         client,
         rpcState,
         chainConfig,
-        dataFetcher,
+        router: routerResult.value,
+        appOptions: options,
         rainSolverTransportConfig,
         transactionGas: options.txGas,
         gasPriceMultiplier: options.gasPriceMultiplier,

src/cli/index.test.ts

@@ -161,7 +161,14 @@ describe("Test RainSolverCli", () => {
                 ["ETH", { address: "0xETH", symbol: "ETH", decimals: 18 }],
                 ["USDC", { address: "0xUSDC", symbol: "USDC", decimals: 6 }],
             ]),
-            dataFetcher: { test: "data" },
+            router: {
+                sushi: {
+                    reset: vi.fn(),
+                    dataFetcher: {
+                        test: "data",
+                    },
+                },
+            },
             liquidityProviders: ["uniswap"],
             client: {},
             avgGasCost: 1000000000000000000n,
@@ -533,24 +540,15 @@ describe("Test RainSolverCli", () => {
             const pastTime = Date.now() - 100000;
             (rainSolverCli as any).nextDatafetcherReset = pastTime;
 
-            const mockNewDataFetcher = { test: "new_data" };
-            const RainDataFetcher = await import("sushi");
-            (RainDataFetcher.RainDataFetcher.init as Mock).mockResolvedValue(mockNewDataFetcher);
-
             await rainSolverCli.maybeResetDataFetcher();
 
             expect((rainSolverCli as any).nextDatafetcherReset).toBeGreaterThan(pastTime);
-            expect(RainDataFetcher.RainDataFetcher.init).toHaveBeenCalledWith(
-                1,
-                mockState.client,
-                mockState.liquidityProviders,
-            );
-            expect(rainSolverCli.state.dataFetcher).toBe(mockNewDataFetcher);
+            expect(mockState.router.sushi?.reset).toHaveBeenCalledTimes(1);
         });
 
         it("should not reset when time has not passed", async () => {
             const futureTime = Date.now() + 100000;
-            const originalDataFetcher = rainSolverCli.state.dataFetcher;
+            const originalDataFetcher = rainSolverCli.state.router.sushi!.dataFetcher;
             (rainSolverCli as any).nextDatafetcherReset = futureTime;
 
             const RainDataFetcher = await import("sushi");
@@ -560,13 +558,13 @@ describe("Test RainSolverCli", () => {
 
             expect((rainSolverCli as any).nextDatafetcherReset).toBe(futureTime);
             expect(initSpy).not.toHaveBeenCalled();
-            expect(rainSolverCli.state.dataFetcher).toBe(originalDataFetcher);
+            expect(rainSolverCli.state.router.sushi!.dataFetcher).toBe(originalDataFetcher);
         });
 
         it("should handle data fetcher init failure gracefully", async () => {
             const pastTime = Date.now() - 100000;
             (rainSolverCli as any).nextDatafetcherReset = pastTime;
-            const originalDataFetcher = rainSolverCli.state.dataFetcher;
+            const originalDataFetcher = rainSolverCli.state.router.sushi!.dataFetcher;
 
             const RainDataFetcher = await import("sushi");
             (RainDataFetcher.RainDataFetcher.init as Mock).mockRejectedValue(
@@ -576,7 +574,7 @@ describe("Test RainSolverCli", () => {
             await rainSolverCli.maybeResetDataFetcher();
 
             expect((rainSolverCli as any).nextDatafetcherReset).toBeGreaterThan(pastTime);
-            expect(rainSolverCli.state.dataFetcher).toBe(originalDataFetcher);
+            expect(rainSolverCli.state.router.sushi!.dataFetcher).toBe(originalDataFetcher);
         });
     });
 
@@ -675,9 +673,10 @@ describe("Test RainSolverCli", () => {
             };
             const mockRoundCtx = { test: "context" };
             const mockResults = [
-                { isOk: () => true, value: { txUrl: "https://etherscan.io/tx/0x123" } },
-                { isOk: () => false, error: { txUrl: "https://etherscan.io/tx/0x456" } },
-                { isOk: () => true, value: { txUrl: undefined } },
+                Result.ok({ txUrl: "https://etherscan.io/tx/0x123" }),
+                Result.ok({ txUrl: "https://etherscan.io/tx/0x456" }),
+                Result.ok({ txUrl: undefined }),
+                Result.err({ txUrl: "https://etherscan.io/tx/0x789" }),
             ];
             const mockReports = [{ name: "report-1" }, { name: "report-2" }];
             const mockCheckpointReports = [{ name: "checkpoint-1" }];
@@ -696,10 +695,13 @@ describe("Test RainSolverCli", () => {
                 context: mockRoundCtx,
             });
             expect(mockRoundSpan.setAttribute).toHaveBeenCalledWith("foundOpp", true);
-            expect(mockRoundSpan.setAttribute).toHaveBeenCalledWith("txUrls", [
+            expect(mockRoundSpan.setAttribute).toHaveBeenCalledWith("txUrls.success", [
                 "https://etherscan.io/tx/0x123",
                 "https://etherscan.io/tx/0x456",
             ]);
+            expect(mockRoundSpan.setAttribute).toHaveBeenCalledWith("txUrls.failed", [
+                "https://etherscan.io/tx/0x789",
+            ]);
             expect(mockOrderManager.getCurrentMetadata).toHaveBeenCalledTimes(1);
             expect(mockRoundSpan.setAttribute).toHaveBeenCalledWith("ordersMetadata.key", "value");
         });
@@ -709,10 +711,7 @@ describe("Test RainSolverCli", () => {
                 setAttribute: vi.fn(),
             };
             const mockRoundCtx = { test: "context" };
-            const mockResults = [
-                { isOk: () => true, value: { txUrl: undefined } },
-                { isOk: () => false, error: { txUrl: undefined } },
-            ];
+            const mockResults = [Result.ok({ txUrl: undefined }), Result.err({ txUrl: undefined })];
 
             (mockRainSolver.processNextRound as Mock).mockResolvedValue({
                 results: mockResults,

src/cli/index.ts

@@ -4,11 +4,11 @@ import { formatUnits } from "viem";
 import { AppOptions } from "../config";
 import { RainSolver } from "../core";
 import { OrderManager } from "../order";
+import { ChainId, ChainKey } from "sushi";
 import { WalletManager, WalletType } from "../wallet";
 import { sleep, withBigintSerializer } from "../common";
 import { ErrorSeverity, errorSnapshot } from "../error";
 import { SharedState, SharedStateConfig } from "../state";
-import { ChainId, ChainKey, RainDataFetcher } from "sushi";
 import { SubgraphConfig, SubgraphManager } from "../subgraph";
 import { PreAssembledSpan, RainSolverLogger } from "../logger";
 import { Context, context, Span, SpanStatusCode, trace } from "@opentelemetry/api";
@@ -277,13 +277,7 @@ export class RainSolverCli {
         if (this.nextDatafetcherReset <= now) {
             this.nextDatafetcherReset = now + this.appOptions.poolUpdateInterval * 60 * 1000;
             // reset only if the data fetcher is initialized successfully
-            try {
-                this.state.dataFetcher = await RainDataFetcher.init(
-                    this.state.chainConfig.id as ChainId,
-                    this.state.client,
-                    this.state.liquidityProviders,
-                );
-            } catch {}
+            await this.state.router.sushi?.reset();
         }
     }
 
@@ -298,14 +292,20 @@ export class RainSolverCli {
             span: roundSpan,
             context: roundCtx,
         });
-        const txUrls = results
-            .map((v) => (v.isOk() ? v.value.txUrl : v.error.txUrl))
-            .filter((v) => !!v);
-        const foundOpp = txUrls.length > 0;
-        if (foundOpp) {
+        const successTxs: string[] = [];
+        const failedTxs: string[] = [];
+        results.forEach((v) => {
+            if (v.isOk()) {
+                if (v.value.txUrl) successTxs.push(v.value.txUrl);
+            } else if (v.error.txUrl) {
+                failedTxs.push(v.error.txUrl);
+            }
+        });
+        if (successTxs.length > 0 || failedTxs.length > 0) {
             roundSpan.setAttribute("foundOpp", true);
-            roundSpan.setAttribute("txUrls", txUrls);
         }
+        roundSpan.setAttribute("txUrls.success", successTxs);
+        roundSpan.setAttribute("txUrls.failed", failedTxs);
         roundSpan.setAttribute(
             "ordersMetadata.roundProcessedOrderPairsCount",
             checkpointReports.length,