Use Cases

Accept deposits from any chain. Automatically.

Your protocol lives on one chain. Your users don't. Hypermid lets them deposit from Ethereum, Solana, Arbitrum, PulseChain, or any of 90+ chains — the bridge, the swap, and the delivery happen automatically.

The problem

A user has USDC on Ethereum. Your lending pool is on Arbitrum. Your yield vault is on PulseChain. To deposit, they need to bridge their USDC to the destination chain, wait for confirmation, swap it into the token your protocol accepts, approve the token, and finally deposit. That's four or more transactions across two or more apps.

Each step is a drop-off point. Users abandon flows when friction is high. The ones who do complete the process often overpay on bridge fees or get worse rates because they picked the first option they found instead of the best one.

How Hypermid solves it

•Cross-chain zaps — bridge, swap, and deposit in a single transaction. The user signs once on the source chain and the funds arrive in your protocol on the destination chain, already in the correct token.
•Multi-chain deposit widget — embed a deposit interface that accepts tokens from any chain. Hypermid handles the routing; your protocol receives the deposit.
•PulseChain protocol growth channel — if your protocol is on PulseChain, Hypermid gives users on Ethereum, Arbitrum, and other chains a direct path to deposit. No other aggregator offers this.

Protocol use cases

Lending protocols

Accept collateral deposits from any chain. Users supply USDC from Ethereum into your Arbitrum lending pool in one step.

Yield vaults

Let depositors enter your vault from any chain. The bridge, swap, and vault deposit happen atomically.

DEX liquidity provision

Allow LPs to add liquidity from any chain. Hypermid delivers the correct token pair to your pool contract.

Staking

Users stake from wherever their tokens are. No need to manually bridge first.

Launchpads

Accept participation from any chain. Users contribute with whatever token they hold, and Hypermid converts and delivers.

Governance token acquisition

Let users buy your governance token from any chain and any token — removing friction from community participation.

Integration pattern

The integration follows a simple pattern: your frontend collects the user's source chain and token, requests a quote from Hypermid with your protocol's contract as the destination, and the user signs a single transaction.

typescript

import { ethers } from "ethers";

const HYPERMID_API = "https://api.hypermid.io/v1";

interface DepositParams {
  userAddress: string;
  fromChain: number;
  fromToken: string;
  fromAmount: string;
  // Your protocol's details
  protocolChain: number;
  protocolToken: string;
  vaultAddress: string;
}

async function handleCrossChainDeposit(
  params: DepositParams,
  signer: ethers.Signer
) {
  // 1. Get a quote — Hypermid routes from the user's
  //    source chain/token to your protocol's chain/token
  const quoteRes = await fetch(`${HYPERMID_API}/quote`, {
    method: "GET",
    headers: {
      "x-api-key": process.env.HYPERMID_API_KEY!,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      fromChain: params.fromChain,
      toChain: params.protocolChain,
      fromToken: params.fromToken,
      toToken: params.protocolToken,
      fromAmount: params.fromAmount,
      fromAddress: params.userAddress,
      toAddress: params.vaultAddress,
    }),
  });
  const quote = await quoteRes.json();

  // 2. User signs one transaction on their source chain
  const tx = await signer.sendTransaction({
    to: quote.transactionRequest.to,
    data: quote.transactionRequest.data,
    value: quote.transactionRequest.value,
    gasLimit: quote.transactionRequest.gasLimit,
  });

  // 3. Poll until the funds arrive in your protocol
  let status = "PENDING";
  while (status === "PENDING") {
    await new Promise((r) => setTimeout(r, 5000));
    const statusRes = await fetch(`${HYPERMID_API}/status`, {
      method: "GET",
      headers: {
        "x-api-key": process.env.HYPERMID_API_KEY!,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ txHash: tx.hash }),
    });
    const data = await statusRes.json();
    status = data.status;

    if (status === "FAILED") {
      throw new Error(`Cross-chain deposit failed: ${data.error}`);
    }
  }

  return { txHash: tx.hash, status: "DONE" };
}

Ready to integrate?

Start building with Hypermid's cross-chain infrastructure today.

Read the Integration Guide →Talk to Us →