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.
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');
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.
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);
}
}
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.
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');
}
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
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);
}
}The Flood Fulfiller guarantees the best possible execution prices thanks to our Optimal Routing algorithm.
Flood runs entirely on signatures, meaning you don't have to pay any gas when trading.
We're MEV free and redistribute all trading surplus (arbitrage) to our users, allowing you to earn money when swapping tokens.
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.
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 .
Flood is designed from scratch to deliver top-tier performance. We are obsessed with delivering the highest possible speed, reliability and execution prices.
Flood arms you with powerful tools to create advanced applications, stripping away unnecessary complexity without compromising on capability.
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.