feat: mint + burn routing logic

api/_bridges/across/strategy.ts

@@ -161,5 +161,9 @@ export function getAcrossBridgeStrategy(): BridgeStrategy {
       );
       return tx;
     },
+
+    isRouteSupported: () => {
+      return true;
+    },
   };
 }

api/_bridges/cctp/strategy.ts

@@ -241,6 +241,8 @@ export function getCctpBridgeStrategy(): BridgeStrategy {
         ecosystem: "evm" as const,
       };
     },
+
+    isRouteSupported,
   };
 }
 

api/_bridges/hypercore/strategy.ts

@@ -227,6 +227,8 @@ export function getHyperCoreBridgeStrategy(): BridgeStrategy {
         ecosystem: "evm",
       };
     },
+
+    isRouteSupported,
   };
 }
 

api/_bridges/index.ts

@@ -1,7 +1,13 @@
 import { getAcrossBridgeStrategy } from "./across/strategy";
 import { getHyperCoreBridgeStrategy } from "./hypercore/strategy";
-import { BridgeStrategiesConfig } from "./types";
+import {
+  BridgeStrategiesConfig,
+  BridgeStrategy,
+  GetBridgeStrategyParams,
+} from "./types";
 import { CHAIN_IDs } from "../_constants";
+import { getCctpBridgeStrategy } from "./cctp/strategy";
+import { getBridgeStrategyData } from "./utils";
 
 export const bridgeStrategies: BridgeStrategiesConfig = {
   default: getAcrossBridgeStrategy(),
@@ -13,16 +19,73 @@ export const bridgeStrategies: BridgeStrategiesConfig = {
   // TODO: Add CCTP routes when ready
 };
 
-// TODO: Extend the strategy selection based on more sophisticated logic when we start
-// implementing burn/mint bridges.
-export function getBridgeStrategy({
+export const availableBridgeStrategies = [
+  getAcrossBridgeStrategy(),
+  getHyperCoreBridgeStrategy(),
+  getCctpBridgeStrategy(),
+];
+
+export async function getBridgeStrategy({
   originChainId,
   destinationChainId,
-}: {
-  originChainId: number;
-  destinationChainId: number;
-}) {
+  inputToken,
+  outputToken,
+  amount,
+  amountType,
+  recipient,
+  depositor,
+  logger,
+}: GetBridgeStrategyParams): Promise<BridgeStrategy> {
   const fromToChainOverride =
     bridgeStrategies.fromToChains?.[originChainId]?.[destinationChainId];
-  return fromToChainOverride ?? bridgeStrategies.default;
+  if (fromToChainOverride) {
+    return fromToChainOverride;
+  }
+  const supportedBridgeStrategies = availableBridgeStrategies.filter(
+    (strategy) => strategy.isRouteSupported({ inputToken, outputToken })
+  );
+  if (supportedBridgeStrategies.length === 1) {
+    return supportedBridgeStrategies[0];
+  }
+  const bridgeStrategyData = await getBridgeStrategyData({
+    inputToken,
+    outputToken,
+    amount,
+    amountType,
+    recipient,
+    depositor,
+    logger,
+  });
+  if (!bridgeStrategyData) {
+    return bridgeStrategies.default;
+  }
+  if (!bridgeStrategyData.isUsdcToUsdc) {
+    return getAcrossBridgeStrategy();
+  }
+  if (bridgeStrategyData.isUtilizationHigh) {
+    return getCctpBridgeStrategy();
+  }
+  if (bridgeStrategyData.isLineaSource) {
+    return getAcrossBridgeStrategy();
+  }
+  if (bridgeStrategyData.isFastCctpEligible) {
+    if (bridgeStrategyData.isInThreshold) {
+      return getAcrossBridgeStrategy();
+    }
+    if (bridgeStrategyData.isLargeDeposit) {
+      return getAcrossBridgeStrategy();
+    } else {
+      return getCctpBridgeStrategy();
+    }
+  }
+  if (bridgeStrategyData.canFillInstantly) {
+    return getAcrossBridgeStrategy();
+  } else {
+    if (bridgeStrategyData.isLargeDeposit) {
+      return getAcrossBridgeStrategy();
+    } else {
+      // Use OFT bridge if not CCTP
+      return getCctpBridgeStrategy();
+    }
+  }
 }

api/_bridges/types.ts

@@ -2,6 +2,7 @@ import { BigNumber } from "ethers";
 
 import { CrossSwap, CrossSwapQuotes, Token } from "../_dexes/types";
 import { AppFee, CrossSwapType } from "../_dexes/utils";
+import { Logger } from "@across-protocol/sdk/dist/types/relayFeeCalculator";
 
 export type BridgeStrategiesConfig = {
   default: BridgeStrategy;
@@ -92,4 +93,36 @@ export type BridgeStrategy = {
     quotes: CrossSwapQuotes;
     integratorId?: string;
   }) => Promise<OriginTx>;
+
+  isRouteSupported: (params: {
+    inputToken: Token;
+    outputToken: Token;
+  }) => boolean;
+};
+
+export type BridgeStrategyData =
+  | {
+      canFillInstantly: boolean;
+      isUtilizationHigh: boolean;
+      isUsdcToUsdc: boolean;
+      isLargeDeposit: boolean;
+      isFastCctpEligible: boolean;
+      isLineaSource: boolean;
+      isInThreshold: boolean;
+    }
+  | undefined;
+
+export type BridgeStrategyDataParams = {
+  inputToken: Token;
+  outputToken: Token;
+  amount: BigNumber;
+  amountType: "exactInput" | "exactOutput" | "minOutput";
+  recipient?: string;
+  depositor: string;
+  logger: Logger;
 };
+
+export type GetBridgeStrategyParams = {
+  originChainId: number;
+  destinationChainId: number;
+} & BridgeStrategyDataParams;

api/_bridges/utils.ts

@@ -0,0 +1,104 @@
+import { BigNumber, ethers } from "ethers";
+import { LimitsResponse } from "../_types";
+import * as sdk from "@across-protocol/sdk";
+import { getCachedLimits, ConvertDecimals } from "../_utils";
+import { CHAIN_IDs } from "../_constants";
+import {
+  BridgeStrategyData,
+  BridgeStrategyDataParams,
+} from "../_bridges/types";
+
+export function isFullyUtilized(limits: LimitsResponse): boolean {
+  // Check if utilization is high (>80%)
+  const { liquidReserves, utilizedReserves } = limits.reserves;
+  const _liquidReserves = BigNumber.from(liquidReserves);
+  const _utilizedReserves = BigNumber.from(utilizedReserves);
+
+  const utilizationThreshold = sdk.utils.fixedPointAdjustment.mul(80).div(100); // 80%
+
+  // Calculate current utilization percentage
+  const currentUtilization = _utilizedReserves
+    .mul(sdk.utils.fixedPointAdjustment)
+    .div(_liquidReserves.add(_utilizedReserves));
+
+  return currentUtilization.gt(utilizationThreshold);
+}
+
+/**
+ * Fetches bridge limits and utilization data in parallel to determine strategy requirements
+ */
+export async function getBridgeStrategyData({
+  inputToken,
+  outputToken,
+  amount,
+  amountType,
+  recipient,
+  depositor,
+  logger,
+}: BridgeStrategyDataParams): Promise<BridgeStrategyData> {
+  try {
+    const limits = await getCachedLimits(
+      inputToken.address,
+      outputToken.address,
+      inputToken.chainId,
+      outputToken.chainId,
+      recipient || depositor
+    );
+
+    // Convert amount to input token decimals if it's in output token decimals
+    let amountInInputTokenDecimals = amount;
+    if (amountType === "exactOutput" || amountType === "minOutput") {
+      amountInInputTokenDecimals = ConvertDecimals(
+        outputToken.decimals,
+        inputToken.decimals
+      )(amount);
+    }
+
+    // Check if we can fill instantly
+    const maxDepositInstant = BigNumber.from(limits.maxDepositInstant);
+    const canFillInstantly = amountInInputTokenDecimals.lte(maxDepositInstant);
+
+    // Check if bridge is fully utilized
+    const isUtilizationHigh = isFullyUtilized(limits);
+
+    // Check if input and output tokens are both USDC
+    const isUsdcToUsdc =
+      inputToken.symbol === "USDC" && outputToken.symbol === "USDC";
+
+    // Check if deposit is > 1M USD or within Across threshold
+    const depositAmountUsd = parseFloat(
+      ethers.utils.formatUnits(amountInInputTokenDecimals, inputToken.decimals)
+    );
+    const isInThreshold = depositAmountUsd <= 10_000; // 10K USD
+    const isLargeDeposit = depositAmountUsd > 1_000_000; // 1M USD
+
+    // Check if eligible for Fast CCTP (Polygon, BSC, Solana) and deposit > 10K USD
+    const fastCctpChains = [CHAIN_IDs.POLYGON, CHAIN_IDs.BSC, CHAIN_IDs.SOLANA];
+    const isFastCctpChain =
+      fastCctpChains.includes(inputToken.chainId) ||
+      fastCctpChains.includes(outputToken.chainId);
+    const isFastCctpEligible = isFastCctpChain && depositAmountUsd > 10_000; // 10K USD
+
+    // Check if Linea is the source chain
+    const isLineaSource = inputToken.chainId === CHAIN_IDs.LINEA;
+
+    return {
+      canFillInstantly,
+      isUtilizationHigh,
+      isUsdcToUsdc,
+      isLargeDeposit,
+      isInThreshold,
+      isFastCctpEligible,
+      isLineaSource,
+    };
+  } catch (error) {
+    logger.warn({
+      at: "getBridgeStrategyData",
+      message: "Failed to fetch bridge strategy data, using defaults",
+      error: error instanceof Error ? error.message : String(error),
+    });
+
+    // Safely return undefined if we can't fetch bridge strategy data
+    return undefined;
+  }
+}

api/_types/index.ts

@@ -1,2 +1,3 @@
 export * from "./generic.types";
 export * from "./utility.types";
+export * from "./response.types";

api/_types/response.types.ts

@@ -0,0 +1,19 @@
+export type LimitsResponse = {
+  minDeposit: string;
+  maxDeposit: string;
+  maxDepositInstant: string;
+  maxDepositShortDelay: string;
+  recommendedDepositInstant: string;
+  relayerFeeDetails: {
+    relayFeeTotal: string;
+    relayFeePercent: string;
+    capitalFeePercent: string;
+    capitalFeeTotal: string;
+    gasFeePercent: string;
+    gasFeeTotal: string;
+  };
+  reserves: {
+    liquidReserves: string;
+    utilizedReserves: string;
+  };
+};

api/_utils.ts

@@ -51,7 +51,12 @@ import {
   relayerFeeCapitalCostConfig,
   TOKEN_EQUIVALENCE_REMAPPING,
 } from "./_constants";
-import { PoolStateOfUser, PoolStateResult, TokenInfo } from "./_types";
+import {
+  LimitsResponse,
+  PoolStateOfUser,
+  PoolStateResult,
+  TokenInfo,
+} from "./_types";
 import {
   buildInternalCacheKey,
   getCachedValue,
@@ -1043,21 +1048,7 @@ export const getCachedLimits = async (
   relayer?: string,
   message?: string,
   allowUnmatchedDecimals?: boolean
-): Promise<{
-  minDeposit: string;
-  maxDeposit: string;
-  maxDepositInstant: string;
-  maxDepositShortDelay: string;
-  recommendedDepositInstant: string;
-  relayerFeeDetails: {
-    relayFeeTotal: string;
-    relayFeePercent: string;
-    capitalFeePercent: string;
-    capitalFeeTotal: string;
-    gasFeePercent: string;
-    gasFeeTotal: string;
-  };
-}> => {
+): Promise<LimitsResponse> => {
   const messageTooLong = isMessageTooLong(message ?? "");
 
   const params = {

api/limits.ts

@@ -326,7 +326,8 @@ const handler = async (
         relayerFeeDetails,
       });
 
-      const { liquidReserves: _liquidReserves } = multicallOutput[1];
+      const { liquidReserves: _liquidReserves, utilizedReserves } =
+        multicallOutput[1];
       const [liteChainIdsEncoded] = multicallOutput[2];
       const [poolRebalanceRouteOrigin] = multicallOutput[3];
       const [poolRebalanceRouteDestination] = multicallOutput[4];
@@ -557,6 +558,10 @@ const handler = async (
               tokenGasCost: gasFeeDetails.tokenGasCost.toString(),
             }
           : undefined,
+        reserves: {
+          liquidReserves: String(_liquidReserves),
+          utilizedReserves: String(utilizedReserves),
+        },
       };
       logger.debug({
         at: "Limits",

api/swap/approval/_service.ts

@@ -79,12 +79,18 @@ export async function handleApprovalSwap(
 
   const slippageTolerance = _slippageTolerance ?? slippage * 100;
 
-  // TODO: Extend the strategy selection based on more sophisticated logic when we start
-  // implementing burn/mint bridges.
-  const bridgeStrategy = getBridgeStrategy({
+  const bridgeStrategy = await getBridgeStrategy({
     originChainId: inputToken.chainId,
     destinationChainId: outputToken.chainId,
+    inputToken,
+    outputToken,
+    amount,
+    amountType,
+    recipient,
+    depositor,
+    logger,
   });
+
   const crossSwapQuotes = await getCrossSwapQuotes(
     {
       amount,