Feat/chain specific overrides relay fee calculator (#997)

Signed-off-by: Gerhard Steenkamp <gerhard@umaproject.org>
Co-authored-by: James Morris, MS <96435344+james-a-morris@users.noreply.github.com>

Author: gsteenkamp89

src/relayFeeCalculator/relayFeeCalculator.ts

@@ -47,6 +47,7 @@ type ChainIdAsString = string;
 export interface CapitalCostConfigOverride {
   default: CapitalCostConfig;
   routeOverrides?: Record<ChainIdAsString, Record<ChainIdAsString, CapitalCostConfig>>;
+  destinationChainOverrides?: Record<ChainIdAsString, CapitalCostConfig>;
 }
 export type RelayCapitalCostConfig = CapitalCostConfigOverride | CapitalCostConfig;
 export interface BaseRelayFeeCalculatorConfig {
@@ -189,10 +190,10 @@ export class RelayFeeCalculator {
     this.validateCapitalCostsConfig(config.default);
     // Iterate over all the route overrides and validate them.
     for (const toChainIdRoutes of Object.values(config.routeOverrides || {})) {
-      for (const override of Object.values(toChainIdRoutes)) {
-        this.validateCapitalCostsConfig(override);
-      }
+      Object.values(toChainIdRoutes).forEach(this.validateCapitalCostsConfig);
     }
+    // Validate destination chain overrides
+    Object.values(config.destinationChainOverrides || {}).forEach(this.validateCapitalCostsConfig);
     return config;
   }
 
@@ -310,10 +311,9 @@ export class RelayFeeCalculator {
     // bound to an upper bound. After the kink, the fee % increase will be fixed, and slowly approach the upper bound
     // for very large amount inputs.
     else {
-      const config =
-        isDefined(_originRoute) && isDefined(_destinationRoute)
-          ? tokenCostConfig.routeOverrides?.[_originRoute]?.[_destinationRoute] ?? tokenCostConfig.default
-          : tokenCostConfig.default;
+      const destinationChainOverride = tokenCostConfig?.destinationChainOverrides?.[_destinationRoute || ""];
+      const routeOverride = tokenCostConfig?.routeOverrides?.[_originRoute || ""]?.[_destinationRoute || ""];
+      const config: CapitalCostConfig = routeOverride ?? destinationChainOverride ?? tokenCostConfig.default;
 
       // Scale amount "y" to 18 decimals.
       const y = toBN(_amountToRelay).mul(toBNWei("1", 18 - config.decimals));

test/relayFeeCalculator.test.ts

@@ -29,7 +29,7 @@ import {
   makeCustomTransport,
 } from "./utils";
 import assert from "assert";
-import { TOKEN_SYMBOLS_MAP } from "@across-protocol/constants";
+import { CHAIN_IDs, TOKEN_SYMBOLS_MAP } from "@across-protocol/constants";
 import { EMPTY_MESSAGE, ZERO_ADDRESS } from "../src/constants";
 import { SpokePool } from "@across-protocol/contracts";
 import { QueryBase, QueryBase__factory } from "../src/relayFeeCalculator";
@@ -280,6 +280,121 @@ describe("RelayFeeCalculator", () => {
     assert.equal(client.capitalFeePercent("0", "ZERO_CUTOFF_WBTC").toString(), Number.MAX_SAFE_INTEGER.toString());
     assert.equal(client.capitalFeePercent("0", "WBTC").toString(), Number.MAX_SAFE_INTEGER.toString());
   });
+
+  it("destinationChainOverrides", () => {
+    // Create a client with destination chain and route overrides
+    const token = TOKEN_SYMBOLS_MAP.USDC;
+
+    const customCapitalCostsConfig = {
+      [token.symbol]: {
+        default: {
+          lowerBound: toBNWei("0.0003").toString(),
+          upperBound: toBNWei("0.002").toString(),
+          cutoff: toBNWei("15").toString(),
+          decimals: token.decimals,
+        },
+        destinationChainOverrides: {
+          // Override for destination chain ARBITRUM
+          [CHAIN_IDs.ARBITRUM]: {
+            lowerBound: toBNWei("0.0005").toString(),
+            upperBound: toBNWei("0.003").toString(),
+            cutoff: toBNWei("10").toString(),
+            decimals: token.decimals,
+          },
+        },
+        routeOverrides: {
+          // Override for route MAINNET->ARBITRUM
+          [CHAIN_IDs.MAINNET]: {
+            [CHAIN_IDs.ARBITRUM]: {
+              lowerBound: toBNWei("0.0007").toString(),
+              upperBound: toBNWei("0.004").toString(),
+              cutoff: toBNWei("8").toString(),
+              decimals: token.decimals,
+            },
+          },
+        },
+      },
+    };
+
+    const client = new RelayFeeCalculator({
+      queries,
+      capitalCostsConfig: customCapitalCostsConfig,
+    });
+
+    // Get config values for cleaner assertions
+    const defaultConfig = customCapitalCostsConfig[token.symbol].default;
+    const chainOverride = customCapitalCostsConfig[token.symbol].destinationChainOverrides[CHAIN_IDs.ARBITRUM];
+    const routeOverride = customCapitalCostsConfig[token.symbol].routeOverrides[CHAIN_IDs.MAINNET][CHAIN_IDs.ARBITRUM];
+
+    // Test using default config (no routes specified)
+    const defaultFee = client.capitalFeePercent(toBNWei("1", token.decimals), token.symbol);
+    assert.ok(toBN(defaultFee).gte(toBN(defaultConfig.lowerBound)), "Default fee should be at least the lower bound");
+    assert.ok(toBN(defaultFee).lt(toBN(defaultConfig.upperBound)), "Default fee should be less than the upper bound");
+
+    // Test using destination chain override (only destination specified)
+    const destinationFee = client.capitalFeePercent(
+      toBNWei("1", token.decimals),
+      token.symbol,
+      undefined,
+      CHAIN_IDs.ARBITRUM.toString()
+    );
+    assert.ok(
+      toBN(destinationFee).gte(toBN(chainOverride.lowerBound)),
+      "Destination override fee should be at least its lower bound"
+    );
+    assert.ok(
+      toBN(destinationFee).lt(toBN(chainOverride.upperBound)),
+      "Destination override fee should be less than its upper bound"
+    );
+
+    // Test using route-specific override (both origin and destination specified)
+    const routeFee = client.capitalFeePercent(
+      toBNWei("1", token.decimals),
+      token.symbol,
+      CHAIN_IDs.MAINNET.toString(),
+      CHAIN_IDs.ARBITRUM.toString()
+    );
+    assert.ok(
+      toBN(routeFee).gte(toBN(routeOverride.lowerBound)),
+      "Route override fee should be at least its lower bound"
+    );
+    assert.ok(
+      toBN(routeFee).lt(toBN(routeOverride.upperBound)),
+      "Route override fee should be less than its upper bound"
+    );
+
+    // Test fallback to destination chain override when a route is not specifically overridden
+    const fallbackToDestFee = client.capitalFeePercent(
+      toBNWei("1", token.decimals),
+      token.symbol,
+      CHAIN_IDs.OPTIMISM.toString(),
+      CHAIN_IDs.ARBITRUM.toString()
+    );
+    assert.ok(
+      toBN(fallbackToDestFee).gte(toBN(chainOverride.lowerBound)),
+      "Fallback to destination fee should be at least the destination lower bound"
+    );
+    assert.ok(
+      toBN(fallbackToDestFee).lt(toBN(chainOverride.upperBound)),
+      "Fallback to destination fee should be less than the destination upper bound"
+    );
+
+    // Test fallback to default when route doesn't match and no destination chain override exists
+    const fallbackToDefaultFee = client.capitalFeePercent(
+      toBNWei("1", token.decimals),
+      token.symbol,
+      CHAIN_IDs.OPTIMISM.toString(),
+      CHAIN_IDs.POLYGON.toString()
+    );
+    assert.ok(
+      toBN(fallbackToDefaultFee).gte(toBN(defaultConfig.lowerBound)),
+      "Fallback to default fee should be at least the default lower bound"
+    );
+    assert.ok(
+      toBN(fallbackToDefaultFee).lt(toBN(defaultConfig.upperBound)),
+      "Fallback to default fee should be less than the default upper bound"
+    );
+  });
 });
 
 describe("RelayFeeCalculator: Composable Bridging", function () {