diff --git a/api/_bridges/oft/strategy.ts b/api/_bridges/oft/strategy.ts
index 5778fd5a3..6d0269d66 100644
--- a/api/_bridges/oft/strategy.ts
+++ b/api/_bridges/oft/strategy.ts
@@ -28,10 +28,12 @@ import {
   OFT_MESSENGERS,
   OFT_SHARED_DECIMALS,
   V2_ENDPOINTS,
+  HYPEREVM_OFT_COMPOSER_ADDRESSES,
 } from "./utils/constants";
 import * as chainConfigs from "../../../scripts/chain-configs";
+import { CHAIN_IDs } from "@across-protocol/constants";
 
-const name = "oft";
+const name = "oft" as const;
 
 const capabilities: BridgeCapabilities = {
   ecosystems: ["evm"],
@@ -83,7 +85,7 @@ function roundAmountToSharedDecimals(
  * @param tokenSymbol token being bridged
  * @returns total number of required DVN signatures (requiredDVNs + optionalThreshold)
  */
-async function getRequiredDVNCount(
+export async function getRequiredDVNCount(
   originChainId: number,
   destinationChainId: number,
   tokenSymbol: string
@@ -132,18 +134,19 @@ async function getRequiredDVNCount(
 }
 
 /**
- * Internal helper to get OFT quote from contracts
+ * Internal helper to get OFT quote from contracts.
  * @note This function is designed for input-based quotes (specify input amount, get output amount).
  * Currently works for both input-based and output-based flows because supported tokens (USDT, WBTC) have 0 OFT fees.
  * If we ever add tokens with non-zero OFT fees, we need to refactor this function to handle output-based quotes.
  *
- * @param inputToken source token
- * @param outputToken destination token
- * @param inputAmount amount to send
- * @param recipient recipient address
- * @returns quote data including output amount and fees
+ * @param params The parameters for getting the quote.
+ * @param params.inputToken The input token.
+ * @param params.outputToken The output token.
+ * @param params.inputAmount The input amount.
+ * @param params.recipient The recipient address.
+ * @returns A promise that resolves with the quote data, including input amount, output amount, native fee, and OFT fee amount.
  */
-async function getQuote(params: {
+export async function getQuote(params: {
   inputToken: Token;
   outputToken: Token;
   inputAmount: BigNumber;
@@ -170,21 +173,28 @@ async function getQuote(params: {
     inputToken.symbol,
     inputToken.decimals
   );
-
+  const { toAddress, composeMsg, extraOptions } =
+    outputToken.chainId === CHAIN_IDs.HYPERCORE
+      ? getHyperLiquidComposerMessage(recipient, outputToken.symbol)
+      : { toAddress: recipient, composeMsg: "0x", extraOptions: "0x" };
   // Create SendParam struct for quoting
   const sendParam = createSendParamStruct({
-    destinationChainId: outputToken.chainId,
-    toAddress: recipient,
+    // If sending to Hypercore, the destinationChainId in the SendParam is always HyperEVM
+    destinationChainId:
+      outputToken.chainId === CHAIN_IDs.HYPERCORE
+        ? CHAIN_IDs.HYPEREVM
+        : outputToken.chainId,
+    toAddress,
     amountLD: roundedInputAmount,
     minAmountLD: roundedInputAmount,
+    composeMsg,
+    extraOptions,
   });
-
   // Get quote from OFT contract
   const [messagingFee, oftQuoteResult] = await Promise.all([
     oftMessengerContract.quoteSend(sendParam, false), // false = pay in native token
     oftMessengerContract.quoteOFT(sendParam),
   ]);
-
   const [, , oftReceipt] = oftQuoteResult;
   const nativeFee = BigNumber.from(messagingFee.nativeFee);
 
@@ -209,301 +219,410 @@ async function getQuote(params: {
 }
 
 /**
- * OFT (Omnichain Fungible Token) bridge strategy
+ * Builds the transaction data for an OFT bridge transfer.
+ * This function takes the quotes and other parameters and constructs the transaction data for sending an OFT.
+ * It also handles the special case of sending to Hyperliquid, where a custom message is composed.
+ *
+ * @param params The parameters for building the transaction.
+ * @param params.quotes The quotes for the cross-swap, including the bridge quote.
+ * @param params.integratorId The ID of the integrator.
+ * @returns A promise that resolves with the transaction data.
  */
-export function getOftBridgeStrategy(): BridgeStrategy {
-  const getEstimatedFillTime = async (
-    originChainId: number,
-    destinationChainId: number,
-    tokenSymbol: string
-  ): Promise<number> => {
-    const DEFAULT_BLOCK_TIME_SECONDS = 5;
-
-    // Get source chain required confirmations
-    const originConfirmations = getOftOriginConfirmations(originChainId);
-
-    // Get dynamic DVN count for this specific route
-    const requiredDVNs = await getRequiredDVNCount(
-      originChainId,
-      destinationChainId,
-      tokenSymbol
-    );
+export async function buildOftTx(params: {
+  quotes: CrossSwapQuotes;
+  integratorId?: string;
+}) {
+  const {
+    bridgeQuote,
+    crossSwap,
+    originSwapQuote,
+    destinationSwapQuote,
+    appFee,
+  } = params.quotes;
+
+  // OFT validations
+  if (appFee?.feeAmount.gt(0)) {
+    throw new InvalidParamError({
+      message: "App fee is not supported for OFT bridge transfers",
+    });
+  }
 
-    // Get origin and destination block times from chain configs
-    const originChainConfig = Object.values(chainConfigs).find(
-      (config) => config.chainId === originChainId
-    );
-    const destinationChainConfig = Object.values(chainConfigs).find(
-      (config) => config.chainId === destinationChainId
-    );
-    const originBlockTime =
-      originChainConfig?.blockTimeSeconds ?? DEFAULT_BLOCK_TIME_SECONDS;
-    const destinationBlockTime =
-      destinationChainConfig?.blockTimeSeconds ?? DEFAULT_BLOCK_TIME_SECONDS;
-
-    // Total time ≈ (originBlockTime × originConfirmations) + (destinationBlockTime × (2 + numberOfDVNs))
-    // Source: https://docs.layerzero.network/v2/faq#what-is-the-estimated-delivery-time-for-a-layerzero-message
-    const originTime = originBlockTime * originConfirmations;
-    const destinationTime = destinationBlockTime * (2 + requiredDVNs);
-    const totalTime = originTime + destinationTime;
-
-    return totalTime;
-  };
+  if (originSwapQuote || destinationSwapQuote) {
+    throw new InvalidParamError({
+      message:
+        "Origin/destination swaps are not supported for OFT bridge transfers",
+    });
+  }
 
-  const isRouteSupported = (params: {
-    inputToken: Token;
-    outputToken: Token;
-  }) => {
-    // Both tokens must be the same
-    if (params.inputToken.symbol !== params.outputToken.symbol) {
-      return false;
-    }
+  const originChainId = crossSwap.inputToken.chainId;
+  const destinationChainId = crossSwap.outputToken.chainId;
 
-    // Token must be supported by OFT
-    const oftMessengerContract = OFT_MESSENGERS[params.inputToken.symbol];
-    if (!oftMessengerContract) {
-      return false;
-    }
+  // Get OFT contract address for origin chain
+  const oftMessengerAddress = getOftMessengerForToken(
+    crossSwap.inputToken.symbol,
+    originChainId
+  );
 
-    // Both chains must have OFT contracts configured for the token
-    return Boolean(
-      oftMessengerContract[params.inputToken.chainId] &&
-        oftMessengerContract[params.outputToken.chainId]
-    );
-  };
+  // Get recipient address
+  // If sending to Hyperliquid, compose the special message to contact the Hyperliquid Composer
+  // This includes setting the toAddress to the Composer contract address and creating the composeMsg and extraOptions
+  const { toAddress, composeMsg, extraOptions } =
+    destinationChainId === CHAIN_IDs.HYPERCORE
+      ? getHyperLiquidComposerMessage(
+          crossSwap.recipient!,
+          crossSwap.outputToken.symbol
+        )
+      : {
+          toAddress: crossSwap.recipient!,
+          composeMsg: "0x",
+          extraOptions: "0x",
+        };
 
-  const assertSupportedRoute = (params: {
-    inputToken: Token;
-    outputToken: Token;
-  }) => {
-    if (!isRouteSupported(params)) {
-      throw new InvalidParamError({
-        message: `OFT: Route ${params.inputToken.symbol} -> ${params.outputToken.symbol} is not supported`,
-      });
-    }
-  };
+  const roundedInputAmount = roundAmountToSharedDecimals(
+    bridgeQuote.inputAmount,
+    bridgeQuote.inputToken.symbol,
+    bridgeQuote.inputToken.decimals
+  );
+
+  // Create SendParam struct
+  const sendParam = createSendParamStruct({
+    destinationChainId:
+      destinationChainId === CHAIN_IDs.HYPERCORE
+        ? CHAIN_IDs.HYPEREVM
+        : destinationChainId,
+    toAddress,
+    amountLD: roundedInputAmount,
+    minAmountLD: roundedInputAmount,
+    composeMsg,
+    extraOptions,
+  });
 
+  // Get messaging fee quote
+  const provider = getProvider(originChainId);
+  const oftMessengerContract = new Contract(
+    oftMessengerAddress,
+    OFT_ABI,
+    provider
+  );
+  const messagingFee = await oftMessengerContract.quoteSend(sendParam, false);
+
+  // Encode the send call
+  const iface = new ethers.utils.Interface(OFT_ABI);
+  const callData = iface.encodeFunctionData("send", [
+    sendParam,
+    messagingFee, // MessagingFee struct
+    crossSwap.refundAddress ?? crossSwap.depositor, // refundAddress
+  ]);
+
+  // Handle integrator ID and swap API marker tagging
+  const callDataWithIntegratorId = params.integratorId
+    ? tagIntegratorId(params.integratorId, callData)
+    : callData;
+  const callDataWithMarkers = tagSwapApiMarker(callDataWithIntegratorId);
   return {
-    name,
-    capabilities,
+    chainId: originChainId,
+    from: crossSwap.depositor,
+    to: oftMessengerAddress,
+    data: callDataWithMarkers,
+    value: BigNumber.from(messagingFee.nativeFee), // Must include native fee as value
+    ecosystem: "evm" as const,
+  };
+}
 
-    originTxNeedsAllowance: true,
+/**
+ * Estimates the fill time for an OFT bridge transfer.
+ * The estimation is based on the origin and destination chain block times, the number of origin confirmations, and the number of required DVN signatures.
+ * The formula is: `(originBlockTime * originConfirmations) + (destinationBlockTime * (2 + numberOfDVNs))`
+ * See: https://docs.layerzero.network/v2/faq#what-is-the-estimated-delivery-time-for-a-layerzero-message
+ *
+ * @param originChainId The origin chain ID.
+ * @param destinationChainId The destination chain ID.
+ * @param tokenSymbol The symbol of the token being bridged.
+ * @returns A promise that resolves with the estimated fill time in seconds.
+ */
+export async function getEstimatedFillTime(
+  originChainId: number,
+  destinationChainId: number,
+  tokenSymbol: string
+): Promise<number> {
+  const DEFAULT_BLOCK_TIME_SECONDS = 5;
 
-    getCrossSwapTypes: (params: {
-      inputToken: Token;
-      outputToken: Token;
-      isInputNative: boolean;
-      isOutputNative: boolean;
-    }) => {
-      if (
-        isRouteSupported({
-          inputToken: params.inputToken,
-          outputToken: params.outputToken,
-        })
-      ) {
-        return [CROSS_SWAP_TYPE.BRIDGEABLE_TO_BRIDGEABLE];
-      }
-      return [];
-    },
+  // Get source chain required confirmations
+  const originConfirmations = getOftOriginConfirmations(originChainId);
 
-    getBridgeQuoteRecipient: (crossSwap: CrossSwap) => {
-      return crossSwap.recipient;
-    },
+  // Get dynamic DVN count for this specific route
+  const requiredDVNs = await getRequiredDVNCount(
+    originChainId,
+    destinationChainId,
+    tokenSymbol
+  );
 
-    getBridgeQuoteMessage: (_crossSwap: CrossSwap, _appFee?: AppFee) => {
-      return "0x";
-    },
+  // Get origin and destination block times from chain configs
+  const originChainConfig = Object.values(chainConfigs).find(
+    (config) => config.chainId === originChainId
+  );
+  const destinationChainConfig = Object.values(chainConfigs).find(
+    (config) => config.chainId === destinationChainId
+  );
+  const originBlockTime =
+    originChainConfig?.blockTimeSeconds ?? DEFAULT_BLOCK_TIME_SECONDS;
+  const destinationBlockTime =
+    destinationChainConfig?.blockTimeSeconds ?? DEFAULT_BLOCK_TIME_SECONDS;
+
+  // Total time ≈ (originBlockTime × originConfirmations) + (destinationBlockTime × (2 + numberOfDVNs))
+  // Source: https://docs.layerzero.network/v2/faq#what-is-the-estimated-delivery-time-for-a-layerzero-message
+  const originTime = originBlockTime * originConfirmations;
+  const destinationTime = destinationBlockTime * (2 + requiredDVNs);
+  const totalTime = originTime + destinationTime;
+
+  return totalTime;
+}
+
+/**
+ * Checks if a route is supported for OFT bridging.
+ * A route is supported if the input and output tokens are the same, and the token is configured for OFT on both the origin and destination chains.
+ * It also checks for the special case of bridging to Hyperliquid, where the output token is on the Hypercore chain.
+ *
+ * @param params The parameters for checking the route.
+ * @param params.inputToken The input token.
+ * @param params.outputToken The output token.
+ * @returns True if the route is supported, false otherwise.
+ */
+export function isRouteSupported(params: {
+  inputToken: Token;
+  outputToken: Token;
+}) {
+  // Both tokens must be the same
+  if (
+    params.inputToken.symbol !== params.outputToken.symbol &&
+    params.outputToken.symbol !== `${params.inputToken.symbol}-SPOT`
+  ) {
+    return false;
+  }
+
+  // Token must be supported by OFT
+  const oftMessengerContract = OFT_MESSENGERS[params.inputToken.symbol];
+
+  if (oftMessengerContract[params.inputToken.chainId]) {
+    if (oftMessengerContract[params.outputToken.chainId]) {
+      // Both chains must have OFT contracts configured for the token
+      return true;
+    }
+    const oftComposerContract =
+      HYPEREVM_OFT_COMPOSER_ADDRESSES[params.outputToken.symbol];
+    if (
+      params.outputToken.chainId === CHAIN_IDs.HYPERCORE &&
+      oftComposerContract
+    ) {
+      // The oft transfer is sending OFT directly to hyperCore via the composer contract
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Asserts that a route is supported for OFT bridging.
+ * Throws an error if the route is not supported.
+ *
+ * @param params The parameters for checking the route.
+ * @param params.inputToken The input token.
+ * @param params.outputToken The output token.
+ * @throws {InvalidParamError} If the route is not supported.
+ */
+function assertSupportedRoute(params: {
+  inputToken: Token;
+  outputToken: Token;
+}) {
+  if (!isRouteSupported(params)) {
+    throw new InvalidParamError({
+      message: `OFT: Route ${params.inputToken.symbol} -> ${params.outputToken.symbol} is not supported for bridging from ${params.inputToken.chainId} to ${params.outputToken.chainId}`,
+    });
+  }
+}
+
+/**
+ * Gets a quote for an OFT bridge transfer with a specified output amount.
+ * This function is used when the user wants to receive a specific amount of tokens on the destination chain.
+ *
+ * @param params The parameters for getting the quote.
+ * @param params.inputToken The input token.
+ * @param params.outputToken The output token.
+ * @param params.minOutputAmount The minimum output amount.
+ * @param params.recipient The recipient address.
+ * @returns A promise that resolves with the quote data.
+ */
+async function getOftQuoteForOutput(params: GetOutputBridgeQuoteParams) {
+  const { inputToken, outputToken, minOutputAmount } = params;
+  assertSupportedRoute({ inputToken, outputToken });
 
-    getQuoteForExactInput: async ({
+  // Convert minOutputAmount to input token decimals
+  const minOutputInInputDecimals = ConvertDecimals(
+    outputToken.decimals,
+    inputToken.decimals
+  )(minOutputAmount);
+
+  // Get quote from OFT contracts and estimated fill time in parallel
+  const [{ inputAmount, outputAmount, nativeFee }, estimatedFillTimeSec] =
+    await Promise.all([
+      getQuote({
+        inputToken,
+        outputToken,
+        inputAmount: minOutputInInputDecimals,
+        recipient: params.recipient!,
+      }),
+      getEstimatedFillTime(
+        inputToken.chainId,
+        outputToken.chainId,
+        inputToken.symbol
+      ),
+    ]);
+
+  // OFT precision limitations may prevent delivering the exact minimum amount
+  // We validate against the rounded amount (maximum possible given shared decimals)
+  const roundedMinOutputAmount = roundAmountToSharedDecimals(
+    minOutputAmount,
+    inputToken.symbol,
+    inputToken.decimals
+  );
+  assertMinOutputAmount(outputAmount, roundedMinOutputAmount);
+
+  const nativeToken = getNativeTokenInfo(inputToken.chainId);
+
+  return {
+    bridgeQuote: {
       inputToken,
       outputToken,
-      exactInputAmount,
-      recipient,
-      message: _message,
-    }: GetExactInputBridgeQuoteParams) => {
-      assertSupportedRoute({ inputToken, outputToken });
-
-      const [{ inputAmount, outputAmount, nativeFee }, estimatedFillTimeSec] =
-        await Promise.all([
-          getQuote({
-            inputToken,
-            outputToken,
-            inputAmount: exactInputAmount,
-            recipient: recipient!,
-          }),
-          getEstimatedFillTime(
-            inputToken.chainId,
-            outputToken.chainId,
-            inputToken.symbol
-          ),
-        ]);
-
-      const nativeToken = getNativeTokenInfo(inputToken.chainId);
-
-      return {
-        bridgeQuote: {
-          inputToken,
-          outputToken,
-          inputAmount,
-          outputAmount,
-          minOutputAmount: outputAmount,
-          estimatedFillTimeSec,
-          provider: name,
-          fees: getOftBridgeFees({
-            inputToken,
-            nativeFee,
-            nativeToken,
-          }),
-        },
-      };
+      inputAmount,
+      outputAmount,
+      minOutputAmount,
+      estimatedFillTimeSec,
+      provider: name,
+      fees: getOftBridgeFees({
+        inputToken,
+        nativeFee,
+        nativeToken,
+      }),
     },
+  };
+}
 
-    getQuoteForOutput: async ({
+/**
+ * Determines the cross-swap type for an OFT bridge transfer.
+ * For OFT, the only supported type is `BRIDGEABLE_TO_BRIDGEABLE`, which means that the tokens are the same on both the origin and destination chains.
+ *
+ * @param params The parameters for determining the cross-swap type.
+ * @param params.inputToken The input token.
+ * @param params.outputToken The output token.
+ * @param params.isInputNative A boolean indicating if the input token is native.
+ * @param params.isOutputNative A boolean indicating if the output token is native.
+ * @returns An array of supported cross-swap types.
+ */
+export function getOftCrossSwapTypes(params: {
+  inputToken: Token;
+  outputToken: Token;
+  isInputNative: boolean;
+  isOutputNative: boolean;
+}) {
+  return isRouteSupported({
+    inputToken: params.inputToken,
+    outputToken: params.outputToken,
+  })
+    ? [CROSS_SWAP_TYPE.BRIDGEABLE_TO_BRIDGEABLE]
+    : [];
+}
+
+/**
+ * Gets a quote for an OFT bridge transfer with a specified exact input amount.
+ * This function is used when the user wants to send a specific amount of tokens from the origin chain.
+ *
+ * @param params The parameters for getting the quote.
+ * @param params.inputToken The input token.
+ * @param params.outputToken The output token.
+ * @param params.exactInputAmount The exact input amount.
+ * @param params.recipient The recipient address.
+ * @param params.message An optional message to be sent with the transfer.
+ * @returns A promise that resolves with the quote data.
+ */
+export async function getOftQuoteForExactInput({
+  inputToken,
+  outputToken,
+  exactInputAmount,
+  recipient,
+  message: _message,
+}: GetExactInputBridgeQuoteParams) {
+  assertSupportedRoute({ inputToken, outputToken });
+
+  const [{ inputAmount, outputAmount, nativeFee }, estimatedFillTimeSec] =
+    await Promise.all([
+      getQuote({
+        inputToken,
+        outputToken,
+        inputAmount: exactInputAmount,
+        recipient: recipient!,
+      }),
+      getEstimatedFillTime(
+        inputToken.chainId,
+        outputToken.chainId,
+        inputToken.symbol
+      ),
+    ]);
+
+  const nativeToken = getNativeTokenInfo(inputToken.chainId);
+
+  return {
+    bridgeQuote: {
       inputToken,
       outputToken,
-      minOutputAmount,
-      forceExactOutput: _forceExactOutput,
-      recipient,
-      message: _message,
-    }: GetOutputBridgeQuoteParams) => {
-      assertSupportedRoute({ inputToken, outputToken });
-
-      // Convert minOutputAmount to input token decimals
-      const minOutputInInputDecimals = ConvertDecimals(
-        outputToken.decimals,
-        inputToken.decimals
-      )(minOutputAmount);
-
-      // Get quote from OFT contracts and estimated fill time in parallel
-      const [{ inputAmount, outputAmount, nativeFee }, estimatedFillTimeSec] =
-        await Promise.all([
-          getQuote({
-            inputToken,
-            outputToken,
-            inputAmount: minOutputInInputDecimals,
-            recipient: recipient!,
-          }),
-          getEstimatedFillTime(
-            inputToken.chainId,
-            outputToken.chainId,
-            inputToken.symbol
-          ),
-        ]);
-
-      // OFT precision limitations may prevent delivering the exact minimum amount
-      // We validate against the rounded amount (maximum possible given shared decimals)
-      const roundedMinOutputAmount = roundAmountToSharedDecimals(
-        minOutputAmount,
-        inputToken.symbol,
-        inputToken.decimals
-      );
-      assertMinOutputAmount(outputAmount, roundedMinOutputAmount);
-
-      const nativeToken = getNativeTokenInfo(inputToken.chainId);
-
-      return {
-        bridgeQuote: {
-          inputToken,
-          outputToken,
-          inputAmount,
-          outputAmount,
-          minOutputAmount,
-          estimatedFillTimeSec,
-          provider: name,
-          fees: getOftBridgeFees({
-            inputToken,
-            nativeFee,
-            nativeToken,
-          }),
-        },
-      };
+      inputAmount,
+      outputAmount,
+      minOutputAmount: outputAmount,
+      estimatedFillTimeSec,
+      provider: name,
+      fees: getOftBridgeFees({
+        inputToken,
+        nativeFee,
+        nativeToken,
+      }),
     },
+  };
+}
 
-    buildTxForAllowanceHolder: async (params: {
-      quotes: CrossSwapQuotes;
-      integratorId?: string;
-    }) => {
-      const {
-        bridgeQuote,
-        crossSwap,
-        originSwapQuote,
-        destinationSwapQuote,
-        appFee,
-      } = params.quotes;
-
-      // OFT validations
-      if (appFee?.feeAmount.gt(0)) {
-        throw new InvalidParamError({
-          message: "App fee is not supported for OFT bridge transfers",
-        });
-      }
-
-      if (originSwapQuote || destinationSwapQuote) {
-        throw new InvalidParamError({
-          message:
-            "Origin/destination swaps are not supported for OFT bridge transfers",
-        });
-      }
-
-      const originChainId = crossSwap.inputToken.chainId;
-      const destinationChainId = crossSwap.outputToken.chainId;
-
-      // Get OFT contract address for origin chain
-      const oftMessengerAddress = getOftMessengerForToken(
-        crossSwap.inputToken.symbol,
-        originChainId
-      );
-
-      // Get recipient address
-      const recipient = crossSwap.recipient;
-
-      // Create SendParam struct
-      const sendParam = createSendParamStruct({
-        destinationChainId,
-        toAddress: recipient,
-        amountLD: bridgeQuote.inputAmount,
-        minAmountLD: bridgeQuote.minOutputAmount,
-      });
-
-      // Get messaging fee quote
-      const provider = getProvider(originChainId);
-      const oftMessengerContract = new Contract(
-        oftMessengerAddress,
-        OFT_ABI,
-        provider
-      );
-      const messagingFee = await oftMessengerContract.quoteSend(
-        sendParam,
-        false
-      );
-
-      // Encode the send call
-      const iface = new ethers.utils.Interface(OFT_ABI);
-      const callData = iface.encodeFunctionData("send", [
-        sendParam,
-        messagingFee, // MessagingFee struct
-        crossSwap.refundAddress ?? crossSwap.depositor, // refundAddress
-      ]);
-
-      // Handle integrator ID and swap API marker tagging
-      const callDataWithIntegratorId = params.integratorId
-        ? tagIntegratorId(params.integratorId, callData)
-        : callData;
-      const callDataWithMarkers = tagSwapApiMarker(callDataWithIntegratorId);
-
-      return {
-        chainId: originChainId,
-        from: crossSwap.depositor,
-        to: oftMessengerAddress,
-        data: callDataWithMarkers,
-        value: BigNumber.from(messagingFee.nativeFee), // Must include native fee as value
-        ecosystem: "evm" as const,
-      };
+/**
+ * Gets the OFT bridge strategy.
+ * This function returns the bridge strategy object for OFT, which includes all the necessary functions for quoting, building transactions, and checking for supported routes.
+ *
+ * @returns The OFT bridge strategy.
+ */
+export function getOftBridgeStrategy(): BridgeStrategy {
+  return {
+    name,
+    capabilities,
+    originTxNeedsAllowance: true,
+    getCrossSwapTypes: getOftCrossSwapTypes,
+    getBridgeQuoteRecipient: (crossSwap: CrossSwap) => {
+      return crossSwap.recipient;
     },
+    getBridgeQuoteMessage: (_crossSwap: CrossSwap, _appFee?: AppFee) => {
+      return "0x";
+    },
+    getQuoteForExactInput: getOftQuoteForExactInput,
+    getQuoteForOutput: getOftQuoteForOutput,
+    buildTxForAllowanceHolder: buildOftTx,
     isRouteSupported,
   };
 }
 
+/**
+ * Gets the OFT bridge fees.
+ * For OFT transfers, the fees are simple. There is only a bridge fee, which is the native fee for the messaging layer.
+ *
+ * @param params The parameters for getting the fees.
+ * @param params.inputToken The input token.
+ * @param params.nativeFee The native fee.
+ * @param params.nativeToken The native token.
+ * @returns The OFT bridge fees.
+ */
 function getOftBridgeFees(params: {
   inputToken: Token;
   nativeFee: BigNumber;
@@ -539,3 +658,92 @@ function getOftBridgeFees(params: {
     },
   };
 }
+
+/**
+ * Composes the message for a Hyperliquid transfer.
+ * This function creates the `composeMsg` and `extraOptions` for a Hyperliquid transfer.
+ * The `composeMsg` is the payload for the HyperLiquidComposer, and the `extraOptions` is a custom-packed struct required by the legacy V1-style integration that the Hyperliquid Composer uses.
+ * See: https://docs.layerzero.network/v2/developers/hyperliquid/hyperliquid-concepts
+ *
+ * @param recipient The recipient address on Hyperliquid.
+ * @param tokenSymbol The symbol of the token being transferred.
+ * @returns An object containing the `composeMsg`, `toAddress`, and `extraOptions`.
+ */
+export function getHyperLiquidComposerMessage(
+  recipient: string,
+  tokenSymbol: string
+): {
+  composeMsg: string;
+  toAddress: string;
+  extraOptions: string;
+} {
+  // The `composeMsg` is the payload for the HyperLiquidComposer.
+  // The composer contract's `decodeMessage` function expects: abi.decode(_composeMessage, (uint256, address))
+  // See: https://github.com/LayerZero-Labs/devtools/blob/ed399e9e57e00848910628a2f89b958c11f63162/packages/hyperliquid-composer/contracts/HyperLiquidComposer.sol#L104
+  const composeMsg = ethers.utils.defaultAbiCoder.encode(
+    ["uint256", "address"],
+    [
+      0, // `minMsgValue` is 0 as we are not sending native HYPE tokens.
+      recipient, // `to` is the final user's address on Hyperliquid L1.
+    ]
+  );
+  if (!HYPEREVM_OFT_COMPOSER_ADDRESSES[tokenSymbol]) {
+    throw new InvalidParamError({
+      message: `OFT: No Hyperliquid Composer contract configured for token ${tokenSymbol}`,
+    });
+  }
+  // When composing a message for Hyperliquid, the recipient of the OFT `send` call
+  // is always the Hyperliquid Composer contract on HyperEVM.
+  const toAddress = HYPEREVM_OFT_COMPOSER_ADDRESSES[tokenSymbol];
+
+  /**
+   * @notice Explanation of the custom `extraOptions` payload for the Hyperliquid Composer.
+   *
+   * ## What is `extraOptions`?
+   *
+   * The `extraOptions` parameter is a concept from the LayerZero protocol. It's a `bytes` string used to pass
+   * special instructions and, most importantly, pre-pay for the gas required to execute a transaction on the
+   * destination chain.
+   *
+   * One can think of it as a "secret handshake" or a special delivery form. A standard transaction might fail, but one
+   * with the correct `extraOptions` is recognized and processed by the destination contract.
+   *
+   * ## Why This Specific Value: `0x00030100130300000000000000000000000000000000ea60`
+   *
+   * This value is not a standard gas payment; it's a custom-packed 26-byte struct required by the
+   * integration that the Hyperliquid Composer uses. On-chain analysis of successful transactions proves this is the
+   * only format the contract will accept.
+   * Examples here: https://polygonscan.com/tx/0x3b96ab9962692d173cd6851fc8308fce3ff0eb56209298a632cef9333cfe3f3f
+   * and here: https://arbiscan.io/tx/0x9a71d06971e7b52b7896b82e04e1129a123406e08bb016ed57c77a94cb46f979
+   *
+   * The structure is composed of three distinct parts:
+   *
+   * 1.  **Magic Prefix (`bytes6`):** `0x000301001303`
+   * - This acts as a unique identifier or "handshake," signaling to the LayerZero network and the Composer that
+   * this is a specific type of Hyperliquid-bound message.
+   *
+   * 2.  **Zero Padding (`bytes16`):** `0x00000000000000000000000000000000`
+   * - A fixed block of 16 empty bytes required to maintain the struct's correct layout.
+   *
+   * 3.  **Gas Amount (`uint32`):** `0x0000ea60`
+   * - This is the gas amount (in wei) being airdropped for the destination transaction on HyperEVM.
+   * - The hex value `ea60` is equal to the decimal value **60,000**.
+   *
+   * Any deviation from this 26-byte structure will cause the destination transaction to fail with a parsing error,
+   * as the Composer will not recognize the "handshake."
+   *
+   * ## Proof and Documentation
+   *
+   * - **On-Chain Proof:** The necessity of this exact format is proven by analyzing the input data of successful
+   * `send` transactions on block explorers that bridge to the Hyperliquid Composer. The working example we analyzed
+   * is the primary evidence.
+   *
+   * - **Conceptual Documentation:** While the *specific* value is custom to Hyperliquid, the *concept* of using
+   * `extraOptions` to provide gas comes from the LayerZero protocol's "Adapter Parameters."
+   * See Docs: https://docs.layerzero.network/v2/tools/sdks/options
+   *
+   */
+  const extraOptions = "0x00030100130300000000000000000000000000000000ea60";
+
+  return { composeMsg, toAddress, extraOptions };
+}
diff --git a/api/_bridges/oft/utils/constants.ts b/api/_bridges/oft/utils/constants.ts
index 84fd3810d..8c17b9b5b 100644
--- a/api/_bridges/oft/utils/constants.ts
+++ b/api/_bridges/oft/utils/constants.ts
@@ -43,6 +43,11 @@ export const OFT_MESSENGERS: Record<
   // }
 };
 
+// OFT composer contract addresses per token on hyperEVM
+export const HYPEREVM_OFT_COMPOSER_ADDRESSES: Record<string, string> = {
+  "USDT-SPOT": "0x80123ab57c9bc0c452d6c18f92a653a4ee2e7585",
+};
+
 // Shared decimals for OFT tokens across chains
 // These are the decimal precision values that are consistent across all chains for each token
 export const OFT_SHARED_DECIMALS: Record<string, number> = {
@@ -98,6 +103,7 @@ export const getOftMessengerForToken = (
 
 // Get OFT endpoint ID for a chain
 export const getOftEndpointId = (chainId: number): number => {
+  chainId = chainId === CHAIN_IDs.HYPERCORE ? CHAIN_IDs.HYPEREVM : chainId; // Use HyperEVM's OFT EID for Hypercore. They share the same EID.
   const chainInfo = CHAINS[chainId];
   if (!chainInfo || !chainInfo.oftEid) {
     throw new InvalidParamError({
@@ -293,6 +299,8 @@ export const createSendParamStruct = (params: {
   toAddress: string;
   amountLD: BigNumber;
   minAmountLD: BigNumber;
+  composeMsg?: string;
+  extraOptions?: string;
 }): SendParamStruct => {
   const dstEid = getOftEndpointId(params.destinationChainId);
   return {
@@ -300,8 +308,8 @@ export const createSendParamStruct = (params: {
     to: toBytes32(params.toAddress),
     amountLD: params.amountLD,
     minAmountLD: params.minAmountLD,
-    extraOptions: "0x",
-    composeMsg: "0x",
+    extraOptions: params.extraOptions ?? "0x",
+    composeMsg: params.composeMsg ?? "0x",
     oftCmd: "0x",
   };
 };
diff --git a/e2e-api/bridges/oft/strategy.test.ts b/e2e-api/bridges/oft/strategy.test.ts
new file mode 100644
index 000000000..20610e1c6
--- /dev/null
+++ b/e2e-api/bridges/oft/strategy.test.ts
@@ -0,0 +1,277 @@
+import {
+  getQuote,
+  getEstimatedFillTime,
+  getOftQuoteForExactInput,
+  getRequiredDVNCount,
+  buildOftTx,
+} from "../../../api/_bridges/oft/strategy";
+import { CHAIN_IDs } from "@across-protocol/constants";
+import { CrossSwapQuotes, Token } from "../../../api/_dexes/types";
+import { BigNumber } from "ethers";
+import { TOKEN_SYMBOLS_MAP } from "../../../api/_constants";
+
+describe("OFT Strategy", () => {
+  const arbitrumUSDT: Token = {
+    address: TOKEN_SYMBOLS_MAP.USDT.addresses[CHAIN_IDs.ARBITRUM],
+    symbol: "USDT",
+    decimals: 6,
+    chainId: CHAIN_IDs.ARBITRUM,
+  };
+
+  const polygonUSDT: Token = {
+    address: TOKEN_SYMBOLS_MAP.USDT.addresses[CHAIN_IDs.POLYGON],
+    symbol: "USDT",
+    decimals: 6,
+    chainId: CHAIN_IDs.POLYGON,
+  };
+
+  const hyperCoreUSDT: Token = {
+    address: TOKEN_SYMBOLS_MAP["USDT-SPOT"].addresses[CHAIN_IDs.HYPERCORE],
+    symbol: "USDT-SPOT",
+    decimals: 8,
+    chainId: CHAIN_IDs.HYPERCORE,
+  };
+
+  describe("getRequiredDVNCount", () => {
+    it("should return the DVN count for a valid route", async () => {
+      expect(
+        await getRequiredDVNCount(CHAIN_IDs.ARBITRUM, CHAIN_IDs.POLYGON, "USDT")
+      ).toBeGreaterThan(0);
+
+      expect(
+        await getRequiredDVNCount(
+          CHAIN_IDs.ARBITRUM,
+          CHAIN_IDs.HYPERCORE,
+          "USDT"
+        )
+      ).toBeGreaterThan(0);
+    }, 30000);
+  });
+
+  describe("getQuote", () => {
+    it("should return a valid quote from Arbitrum to Polygon", async () => {
+      const result = await getQuote({
+        inputToken: arbitrumUSDT,
+        outputToken: polygonUSDT,
+        inputAmount: BigNumber.from(1000),
+        recipient: "0x9A8f92a830A5cB89a3816e3D267CB7791c16b04D",
+      });
+
+      expect(result.inputAmount).toEqual(BigNumber.from(1000));
+      expect(result.outputAmount).toBeDefined();
+      expect(result.nativeFee).toBeDefined();
+      expect(result.oftFeeAmount).toBeDefined();
+    }, 30000);
+
+    it("should return a valid quote from Arbitrum to Hyperlane", async () => {
+      const result = await getQuote({
+        inputToken: arbitrumUSDT,
+        outputToken: hyperCoreUSDT,
+        inputAmount: BigNumber.from(1000),
+        recipient: "0x9A8f92a830A5cB89a3816e3D267CB7791c16b04D",
+      });
+
+      expect(result.inputAmount).toEqual(BigNumber.from(1000));
+      expect(result.outputAmount).toBeDefined();
+      expect(result.nativeFee).toBeDefined();
+      expect(result.oftFeeAmount).toBeDefined();
+    }, 30000);
+  });
+
+  describe("getEstimatedFillTime", () => {
+    it("should calculate the estimated fill time correctly", async () => {
+      expect(
+        await getEstimatedFillTime(
+          CHAIN_IDs.ARBITRUM,
+          CHAIN_IDs.POLYGON,
+          "USDT"
+        )
+      ).toBeGreaterThan(0);
+
+      expect(
+        await getEstimatedFillTime(
+          CHAIN_IDs.ARBITRUM,
+          CHAIN_IDs.HYPERCORE,
+          "USDT"
+        )
+      ).toBeGreaterThan(0);
+    });
+  });
+
+  describe("getOftQuoteForExactInput", () => {
+    it("should return a valid quote for an exact input amount", async () => {
+      let result = await getOftQuoteForExactInput({
+        inputToken: arbitrumUSDT,
+        outputToken: polygonUSDT,
+        exactInputAmount: BigNumber.from(1000),
+        recipient: "0x9A8f92a830A5cB89a3816e3D267CB7791c16b04D",
+      });
+
+      expect(result.bridgeQuote.inputAmount).toEqual(BigNumber.from(1000));
+      expect(result.bridgeQuote.outputAmount).toBeDefined();
+      expect(result.bridgeQuote.minOutputAmount).toBeDefined();
+      expect(result.bridgeQuote.estimatedFillTimeSec).toBeGreaterThan(0);
+      expect(result.bridgeQuote.provider).toBe("oft");
+
+      result = await getOftQuoteForExactInput({
+        inputToken: arbitrumUSDT,
+        outputToken: hyperCoreUSDT,
+        exactInputAmount: BigNumber.from(1000),
+        recipient: "0x9A8f92a830A5cB89a3816e3D267CB7791c16b04D",
+      });
+
+      expect(result.bridgeQuote.inputAmount).toEqual(BigNumber.from(1000));
+      expect(result.bridgeQuote.outputAmount).toBeDefined();
+      expect(result.bridgeQuote.minOutputAmount).toBeDefined();
+      expect(result.bridgeQuote.estimatedFillTimeSec).toBeGreaterThan(0);
+      expect(result.bridgeQuote.provider).toBe("oft");
+    }, 30000);
+  });
+
+  describe("buildOftTx", () => {
+    it("should build a valid transaction", async () => {
+      /**
+       * NOTE: This test uses values and specific token addresses from a real,
+       * successful cross-chain transaction to Hyperliquid's Composer contract.
+       *
+       * REASONING:
+       * 1. These values were captured from an actual API quote that successfully completed
+       *    an on-chain cross-chain transfer using the Hyperliquid Composer contract.
+       * 3. The specific token addresses and chain IDs represent the real Arbitrum USDT to
+       *    HyperCore USDT-SPOT route that was validated on-chain.
+       * 4. Since CI tests cannot verify the actual cross-chain transfer completion, maintaining
+       *    the exact request structure from a known-working transaction provides the highest
+       *    confidence that buildOftTx produces valid transaction data.
+       * 5. The Hyperliquid Composer integration uses a very specific `extraOptions` format
+       *    (see strategy.ts for details), and any deviation in the request structure could
+       *    potentially result in a transaction that builds successfully but fails on-chain.
+       *
+       */
+      const quotes: CrossSwapQuotes = {
+        crossSwap: {
+          amount: BigNumber.from(1000000),
+          inputToken: {
+            decimals: 6,
+            symbol: "USDT",
+            address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+            chainId: 42161,
+          },
+          outputToken: {
+            decimals: 8,
+            symbol: "USDT-SPOT",
+            address: "0x200000000000000000000000000000000000010C",
+            chainId: 1337,
+          },
+          depositor: "0x9A8f92a830A5cB89a3816e3D267CB7791c16b04D",
+          recipient: "0x9A8f92a830A5cB89a3816e3D267CB7791c16b04D",
+          slippageTolerance: 1,
+          type: "minOutput",
+          refundOnOrigin: true,
+          isInputNative: false,
+          isOutputNative: false,
+          embeddedActions: [],
+          strictTradeType: true,
+          isDestinationSvm: false,
+          isOriginSvm: false,
+        },
+        bridgeQuote: {
+          inputToken: {
+            decimals: 6,
+            symbol: "USDT",
+            address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+            chainId: 42161,
+          },
+          outputToken: {
+            decimals: 8,
+            symbol: "USDT-SPOT",
+            address: "0x200000000000000000000000000000000000010C",
+            chainId: 1337,
+          },
+          inputAmount: BigNumber.from(10000),
+          outputAmount: BigNumber.from(1000000),
+          minOutputAmount: BigNumber.from(1000000),
+          estimatedFillTimeSec: 24,
+          provider: "oft",
+          fees: {
+            totalRelay: {
+              pct: BigNumber.from(0),
+              total: BigNumber.from(0),
+              token: {
+                decimals: 6,
+                symbol: "USDT",
+                address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+                chainId: 42161,
+              },
+            },
+            relayerCapital: {
+              pct: BigNumber.from(0),
+              total: BigNumber.from(0),
+              token: {
+                decimals: 6,
+                symbol: "USDT",
+                address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+                chainId: 42161,
+              },
+            },
+            relayerGas: {
+              pct: BigNumber.from(0),
+              total: BigNumber.from(0),
+              token: {
+                decimals: 6,
+                symbol: "USDT",
+                address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+                chainId: 42161,
+              },
+            },
+            lp: {
+              pct: BigNumber.from(0),
+              total: BigNumber.from(0),
+              token: {
+                decimals: 6,
+                symbol: "USDT",
+                address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+                chainId: 42161,
+              },
+            },
+            bridgeFee: {
+              pct: BigNumber.from(0),
+              total: BigNumber.from("0x1522fe82c8c1"),
+              token: {
+                chainId: 42161,
+                address: "0x0000000000000000000000000000000000000000",
+                decimals: 18,
+                symbol: "ETH",
+              },
+            },
+          },
+          message: "0x",
+        },
+        contracts: {
+          depositEntryPoint: {
+            name: "SpokePoolPeriphery",
+            address: "0x89415a82d909a7238d69094C3Dd1dCC1aCbDa85C",
+          },
+        },
+        appFee: {
+          feeAmount: BigNumber.from(0),
+          feeToken: {
+            decimals: 8,
+            symbol: "USDT-SPOT",
+            address: "0x200000000000000000000000000000000000010C",
+            chainId: 1337,
+          },
+          feeActions: [],
+        },
+      };
+
+      const result = await buildOftTx({ quotes });
+      expect(result).toBeDefined();
+      expect(result.chainId).toBe(42161);
+      expect(result.data).toBeDefined();
+      expect(result.value).toBeDefined();
+      expect(result.from).toBe("0x9A8f92a830A5cB89a3816e3D267CB7791c16b04D");
+      expect(result.to).toBe("0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92");
+      expect(result.ecosystem).toBe("evm");
+    }, 30000);
+  });
+});
diff --git a/package.json b/package.json
index 2653832a7..34807acc1 100644
--- a/package.json
+++ b/package.json
@@ -4,8 +4,6 @@
   "private": true,
   "license": "AGPL-3.0-only",
   "dependencies": {
-    "@across-protocol/constants": "^3.1.80",
-    "@across-protocol/contracts": "^4.1.11",
     "@across-protocol/constants": "^3.1.82",
     "@across-protocol/contracts": "^4.1.11",
     "@across-protocol/contracts-v4.1.1": "npm:@across-protocol/contracts@4.1.1",
diff --git a/scripts/tests/_swap-cases.ts b/scripts/tests/_swap-cases.ts
index b45468e3f..59d07d186 100644
--- a/scripts/tests/_swap-cases.ts
+++ b/scripts/tests/_swap-cases.ts
@@ -404,3 +404,26 @@ export const SOLANA_CASES = [
     },
   },
 ];
+
+export const USDT_OFT_COMPOSER_CASE = [
+  // Arbitrum -> HYPERCORE USDT
+  {
+    labels: [
+      "OFT",
+      "B2B",
+      "EXACT_INPUT",
+      "USDT - USDT-SPOT",
+      "ARBITRUM - HYPERCORE",
+    ],
+    params: {
+      amount: ethers.utils.parseUnits("1", 6).toString(),
+      tradeType: "minOutput",
+      inputToken: TOKEN_SYMBOLS_MAP.USDT.addresses[CHAIN_IDs.ARBITRUM],
+      originChainId: CHAIN_IDs.ARBITRUM,
+      outputToken:
+        TOKEN_SYMBOLS_MAP["USDT-SPOT"].addresses[CHAIN_IDs.HYPERCORE],
+      destinationChainId: CHAIN_IDs.HYPERCORE,
+      depositor: evmDepositor,
+    },
+  },
+];
diff --git a/scripts/tests/_swap-utils.ts b/scripts/tests/_swap-utils.ts
index 2296d50e6..af8cb880c 100644
--- a/scripts/tests/_swap-utils.ts
+++ b/scripts/tests/_swap-utils.ts
@@ -22,6 +22,7 @@ import {
   EXACT_INPUT_CASES,
   LENS_CASES,
   SOLANA_CASES,
+  USDT_OFT_COMPOSER_CASE,
 } from "./_swap-cases";
 
 dotenv.config({
@@ -369,6 +370,8 @@ export async function signAndWaitAllowanceFlow(params: {
       data: params.swapResponse.swapTx.data,
       value: params.swapResponse.swapTx.value,
       gasLimit: params.swapResponse.swapTx.gas,
+      maxFeePerGas: params.swapResponse.swapTx.maxFeePerGas,
+      maxPriorityFeePerGas: params.swapResponse.swapTx.maxPriorityFeePerGas,
     });
     console.log("Tx hash: ", tx.hash);
     await tx.wait();
diff --git a/test/api/_bridges/oft/strategy.test.ts b/test/api/_bridges/oft/strategy.test.ts
new file mode 100644
index 000000000..9299d981a
--- /dev/null
+++ b/test/api/_bridges/oft/strategy.test.ts
@@ -0,0 +1,273 @@
+import {
+  getHyperLiquidComposerMessage,
+  isRouteSupported,
+  getOftCrossSwapTypes,
+} from "../../../../api/_bridges/oft/strategy";
+import {
+  HYPEREVM_OFT_COMPOSER_ADDRESSES,
+  OFT_MESSENGERS,
+} from "../../../../api/_bridges/oft/utils/constants";
+import { CHAIN_IDs } from "@across-protocol/constants";
+import { Token } from "../../../../api/_dexes/types";
+import { ethers } from "ethers";
+import { CROSS_SWAP_TYPE } from "../../../../api/_dexes/utils";
+import { TOKEN_SYMBOLS_MAP } from "../../../../api/_constants";
+import { assert } from "console";
+
+describe("OFT Strategy", () => {
+  describe("getHyperLiquidComposerMessage", () => {
+    const recipient = "0x0000000000000000000000000000000000000001";
+    const tokenSymbol = "USDT-SPOT";
+
+    it("should return the correct message for HyperLiquid", () => {
+      const { composeMsg, toAddress, extraOptions } =
+        getHyperLiquidComposerMessage(recipient, tokenSymbol);
+
+      const expectedComposeMsg = ethers.utils.defaultAbiCoder.encode(
+        ["uint256", "address"],
+        [0, recipient]
+      );
+
+      expect(composeMsg).toBe(expectedComposeMsg);
+      expect(toAddress).toBe(HYPEREVM_OFT_COMPOSER_ADDRESSES[tokenSymbol]);
+      expect(extraOptions).toBe(
+        "0x00030100130300000000000000000000000000000000ea60"
+      );
+    });
+
+    it("should throw an error for an unsupported token", () => {
+      const unsupportedToken = "UNSUPPORTED";
+      expect(() =>
+        getHyperLiquidComposerMessage(recipient, unsupportedToken)
+      ).toThrow(
+        `OFT: No Hyperliquid Composer contract configured for token ${unsupportedToken}`
+      );
+    });
+  });
+
+  describe("isRouteSupported", () => {
+    it("should return true for all supported routes", () => {
+      for (const tokenSymbol in OFT_MESSENGERS) {
+        const supportedChains = Object.keys(OFT_MESSENGERS[tokenSymbol]).map(
+          Number
+        );
+        // Need at least two supported chains to form a route
+        if (supportedChains.length < 2) continue;
+
+        for (
+          let originIndex = 0;
+          originIndex < supportedChains.length;
+          originIndex++
+        ) {
+          for (
+            let destinationIndex = originIndex + 1;
+            destinationIndex < supportedChains.length;
+            destinationIndex++
+          ) {
+            const tokens =
+              TOKEN_SYMBOLS_MAP[tokenSymbol as keyof typeof TOKEN_SYMBOLS_MAP];
+            assert(
+              tokens,
+              `Token ${tokenSymbol} not found in TOKEN_SYMBOLS_MAP`
+            );
+
+            const originChainId = supportedChains[originIndex];
+            const destinationChainId = supportedChains[destinationIndex];
+            const params = {
+              inputToken: {
+                symbol: tokenSymbol,
+                chainId: originChainId,
+                address: tokens.addresses[originChainId],
+                decimals: tokens.decimals,
+              },
+              outputToken: {
+                symbol: tokenSymbol,
+                chainId: destinationChainId,
+                address: tokens.addresses[destinationChainId],
+                decimals: tokens.decimals,
+              },
+            };
+            expect(isRouteSupported(params)).toBe(true);
+          }
+        }
+      }
+    });
+
+    it("should return false if tokens are different", () => {
+      const tokenSymbols = Object.keys(OFT_MESSENGERS);
+      // Need at least two supported tokens to form a route
+      if (tokenSymbols.length < 2) return;
+
+      const tokenA = tokenSymbols[0];
+      const tokenB = tokenSymbols[1];
+      const chainA = Number(Object.keys(OFT_MESSENGERS[tokenA])[0]);
+      const chainB = Number(Object.keys(OFT_MESSENGERS[tokenB])[0]);
+
+      const params = {
+        inputToken: {
+          symbol: tokenA,
+          chainId: chainA,
+          address: "0x1",
+          decimals: 18,
+        },
+        outputToken: {
+          symbol: tokenB,
+          chainId: chainB,
+          address: "0x2",
+          decimals: 18,
+        },
+      };
+      expect(isRouteSupported(params)).toBe(false);
+    });
+
+    it("should return false if origin chain is not supported", () => {
+      for (const tokenSymbol in OFT_MESSENGERS) {
+        const supportedChains = Object.keys(OFT_MESSENGERS[tokenSymbol]).map(
+          Number
+        );
+        if (supportedChains.length === 0) continue;
+
+        const supportedChain = supportedChains[0];
+        const unsupportedChain = 99999; // A chain ID that is not in any list
+
+        const params = {
+          inputToken: {
+            symbol: tokenSymbol,
+            chainId: unsupportedChain,
+            address: "0x1",
+            decimals: 18,
+          },
+          outputToken: {
+            symbol: tokenSymbol,
+            chainId: supportedChain,
+            address: "0x1",
+            decimals: 18,
+          },
+        };
+        expect(isRouteSupported(params)).toBe(false);
+      }
+    });
+
+    it("should return true for supported routes to Hypercore", () => {
+      for (const tokenSymbol in HYPEREVM_OFT_COMPOSER_ADDRESSES) {
+        if (OFT_MESSENGERS[tokenSymbol]) {
+          const supportedChains = Object.keys(OFT_MESSENGERS[tokenSymbol]).map(
+            Number
+          );
+          // Needs at least one supported chain for the token symbol to form a route to Hypercore
+          if (supportedChains.length === 0) continue;
+
+          const supportedChain = supportedChains[0];
+          const params = {
+            inputToken: {
+              symbol: tokenSymbol,
+              chainId: supportedChain,
+              address: "0x1",
+              decimals: 18,
+            },
+            outputToken: {
+              symbol: tokenSymbol,
+              chainId: CHAIN_IDs.HYPERCORE,
+              address: "0x1",
+              decimals: 18,
+            },
+          };
+          expect(isRouteSupported(params)).toBe(true);
+        }
+      }
+    });
+
+    it("should return false for unsupported routes to Hypercore", () => {
+      const allOftSymbols = Object.keys(OFT_MESSENGERS);
+      const hypercoreSymbols = Object.keys(HYPEREVM_OFT_COMPOSER_ADDRESSES);
+      const unsupportedSymbol = allOftSymbols.find(
+        (s) => !hypercoreSymbols.includes(s)
+      );
+
+      if (unsupportedSymbol) {
+        const supportedChains = Object.keys(
+          OFT_MESSENGERS[unsupportedSymbol]
+        ).map(Number);
+        if (supportedChains.length > 0) {
+          const params = {
+            inputToken: {
+              symbol: unsupportedSymbol,
+              chainId: supportedChains[0],
+              address: "0x1",
+              decimals: 18,
+            },
+            outputToken: {
+              symbol: unsupportedSymbol,
+              chainId: CHAIN_IDs.HYPERCORE,
+              address: "0x1",
+              decimals: 18,
+            },
+          };
+          expect(isRouteSupported(params)).toBe(false);
+        }
+      }
+    });
+  });
+
+  describe("getOftCrossSwapTypes", () => {
+    const arbitrumUSDT: Token = {
+      address: TOKEN_SYMBOLS_MAP.USDT.addresses[CHAIN_IDs.ARBITRUM],
+      symbol: "USDT",
+      decimals: 6,
+      chainId: CHAIN_IDs.ARBITRUM,
+    };
+
+    const polygonUSDT: Token = {
+      address: TOKEN_SYMBOLS_MAP.USDT.addresses[CHAIN_IDs.POLYGON],
+      symbol: "USDT",
+      decimals: 6,
+      chainId: CHAIN_IDs.POLYGON,
+    };
+
+    const hyperCoreUSDT: Token = {
+      address: TOKEN_SYMBOLS_MAP["USDT-SPOT"].addresses[CHAIN_IDs.HYPERCORE],
+      symbol: "USDT-SPOT",
+      decimals: 8,
+      chainId: CHAIN_IDs.HYPERCORE,
+    };
+
+    const unsupportedToken: Token = {
+      address: "0x123",
+      symbol: "UNSUPPORTED",
+      decimals: 18,
+      chainId: CHAIN_IDs.ARBITRUM,
+    };
+    it("should return BRIDGEABLE_TO_BRIDGEABLE if route is supported", () => {
+      const result = getOftCrossSwapTypes({
+        inputToken: arbitrumUSDT,
+        outputToken: polygonUSDT,
+        isInputNative: false,
+        isOutputNative: false,
+      });
+
+      expect(result).toEqual([CROSS_SWAP_TYPE.BRIDGEABLE_TO_BRIDGEABLE]);
+    });
+
+    it("should return BRIDGEABLE_TO_BRIDGEABLE if route is supported", () => {
+      const result = getOftCrossSwapTypes({
+        inputToken: polygonUSDT,
+        outputToken: hyperCoreUSDT,
+        isInputNative: false,
+        isOutputNative: false,
+      });
+
+      expect(result).toEqual([CROSS_SWAP_TYPE.BRIDGEABLE_TO_BRIDGEABLE]);
+    });
+
+    it("should return an empty array if route is not supported", () => {
+      const result = getOftCrossSwapTypes({
+        inputToken: arbitrumUSDT,
+        outputToken: unsupportedToken,
+        isInputNative: false,
+        isOutputNative: false,
+      });
+
+      expect(result).toEqual([]);
+    });
+  });
+});