Maximize your Trading Profit

We built the Next Generation DEX aggregator to give you the best price - gasless and MEV-free.

Backed by the best

Build with Flood

Wallet Providers

Enable in-wallet trading within 10 minutes. Send orders with ease, and when you're ready, deploy your own Zone, charge your own fees, and start monetizing your order flow.
With Flood's fulfiller by your side, your users get great prices from day one.

Mac OS buttons
import { arbitrum } from 'flood-sdk/chains';
import {
  newOrder, orderHash, permit2Domain,
  permit2WitnessTypes, PrimaryType, intoPermit, submitOrder,
} from 'flood-sdk';

const MY_WALLET_ZONE = '0x...';

const order = newOrder(arbitrum, {
  offerer: '0x...',
  zone: MY_WALLET_ZONE,
  tokensIn: { [USDC_ADDRESS]: 100000000n },
  tokenOut: WETH_ADDRESS
});

// Can be used as unique identifier on a per-chain basis
const myOrderHash = orderHash(arbitrum, order);
const signature = await wallet.signTypedData({
  domain: permit2Domain(arbitrum),
  types: permit2WitnessTypes,
  message: intoPermit(arbitrum, order),
  primaryType: PrimaryType.NEW,
});

await submitOrder(arbitrum, { order, signature });
console.log('Order submitted');

Protocol Developers

Flood makes great execution a first class DeFi primitive unlocking a new design space.
Execute your protocol logic synchronously before and after a trade, rebalance your vaults, bridge tokens, your imagination is the limit.

Mac OS buttons
pragma solidity ^0.8.19;

contract YourProtocol {
  function preFloodTrade(Order calldata order) external {
    // Do some action based on the order, before the trade is executed
    _protocolAction(order);
  }

  function isValidSignature(bytes32 msgHash, bytes memory signature) external view returns (bytes4) {
    /// @dev Check if the signature is valid
    if(orders[msgHash].signer != msgHash.recover(signature)) {
      return BAD_SIGNATURE;
    }
    return this.isValidSignature.selector;
  }

  function postFloodTrade(Order calldata order, uint amountOut) external {
    // Do some action based on the order, after the trade is executed
    _protocolAction(order);
  }
}

Traders

Focus on your edge, not execution. Let Flood's fulfiller take care of giving you the best possible execution and minize your trading costs.
Deploy new trading strategies in minutes rather than days and experiment with complex ones like CEX/DEX arbitrage.
Not a developer? We have an interface for you.

Mac OS buttons
import { arbitrum } from 'flood-sdk/chains';
import {
  quote, newOrder, orderHash, permit2Domain, permit2WitnessTypes,
  PrimaryType, intoPermit, submitOrder,
} from 'flood-sdk';
import { maxUint256 } from 'viem';

const quoteWeth = quote(arbitrum, {
  tokensIn: { [USDC_ADDRESS]: 100000000n },
  tokenOut: WETH_ADDRESS,
});
// Update your trading strategy with new data
updateMA(quoteWeth, Date.now());

if (MACross()) {
  const order = newOrder(arbitrum, {
    offerer: '0x...',
    zone: arbitrum.contracts.defaultZone.address,
    tokensIn: { [USDC_ADDRESS]: 100000000n },
    tokenOut: WETH_ADDRESS,
    minAmountOut: (quoteWeth * 999n) / 1000n,
    deadline: maxUint256,
    nonce: 0n,
  });

  // Can be used as unique identifier on a per-chain basis
  const myOrderHash = orderHash(arbitrum, order);
  const signature = await wallet.signTypedData({
    domain: permit2Domain(arbitrum),
    types: permit2WitnessTypes,
    message: intoPermit(arbitrum, order),
    primaryType: PrimaryType.NEW,
  });

  await submitOrder(arbitrum, { order, signature });
  console.log('Order submitted');
}

Asset Managers

Execute large size trades with minimal market impact. Seamlessly integrate with lending markets for just-in-time deposits and withdrawals, or effortlessly bridge assets post-trade.
Leverage your own zone to apply fees and optimize revenue on every transaction

Mac OS buttons
pragma solidity ^0.8.19;

contract YourAssetManager is AccessControl {
  function preFloodTrade(Order calldata order) external {
    // Withdraw from a lending market
    lending.withdraw(order.offer.token, order.offer.amount);
  }

  function isValidSignature(bytes32 msgHash, bytes memory signature) external view returns (bytes4) {
    /// @dev Check if the signature is valid
    address maybe_signer = msgHash.recover(signature);
    if(!hasRole(REBALANCER_ROLE, maybe_signer)) {
      return BAD_SIGNATURE;
    }
    return this.isValidSignature.selector;
  }

  function postFloodTrade(Order calldata order, uint amountOut) external {
    // Deposit the token bought into a lending market
    lending.deposit(order.consideration.token, amountOut);
  }
}

Trade on Flood

Best prices

The Flood Fulfiller guarantees the best possible execution prices thanks to our Optimal Routing algorithm.

Gasless trading

Flood runs entirely on signatures, meaning you don't have to pay any gas when trading.

MEV free

We're MEV free and redistribute all trading surplus (arbitrage) to our users, allowing you to earn money when swapping tokens.

We solved Optimal Routing

All zones deployed on Flood get access to our Optimal Fulfiller.
Designed from the ground up with performance in mind, and heavily optimized, the Optimal Fulfiller ensures your trades execute at the mathematically proven best price.

Months of dedicated research, engineering, and a couple of PhDs to build it. Now it's available for you wether you're building or trading.

optimal routing performance

FAQ

  • Currently, Flood is live on Arbitrum One. We're expanding to Ethereum Mainnet, Base, and Optimism in Q1 2024.

  • Flood supports any token as long as the fulfiller you choose supports them. The Flood Optimal Fulfiller supports USDC, USDT, DAI, WETH, WBTC, LINK, GMX, with more tokens coming in Q1 2024.

  • You can use our fast and secure trading app called FloodSwap .

  • Send us an email at devs@flood.bid or simply reach out on Discord .

Our Principles

Performance

Flood is designed from scratch to deliver top-tier performance. We are obsessed with delivering the highest possible speed, reliability and execution prices.

Power

Flood arms you with powerful tools to create advanced applications, stripping away unnecessary complexity without compromising on capability.

Simplicity

Flood does the heavy lifting so you don't have to.
Sophisticated and hard to build on the inside, but simple and user-friendly on the outside.