371 lines
13 KiB
Solidity
371 lines
13 KiB
Solidity
// SPDX-License-Identifier: MIT
|
|
pragma solidity ^0.8.19;
|
|
|
|
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
|
|
import "@openzeppelin/contracts/access/Ownable.sol";
|
|
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
|
|
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
|
|
|
|
interface IUniswapV3Pool {
|
|
function flash(
|
|
address recipient,
|
|
uint256 amount0,
|
|
uint256 amount1,
|
|
bytes calldata data
|
|
) external;
|
|
|
|
function token0() external view returns (address);
|
|
function token1() external view returns (address);
|
|
function fee() external view returns (uint24);
|
|
}
|
|
|
|
interface IUniswapV3Router {
|
|
struct ExactInputSingleParams {
|
|
address tokenIn;
|
|
address tokenOut;
|
|
uint24 fee;
|
|
address recipient;
|
|
uint256 deadline;
|
|
uint256 amountIn;
|
|
uint256 amountOutMinimum;
|
|
uint160 sqrtPriceLimitX96;
|
|
}
|
|
|
|
function exactInputSingle(ExactInputSingleParams calldata params)
|
|
external
|
|
payable
|
|
returns (uint256 amountOut);
|
|
}
|
|
|
|
interface ICamelotRouter {
|
|
function swapExactTokensForTokens(
|
|
uint amountIn,
|
|
uint amountOutMin,
|
|
address[] calldata path,
|
|
address to,
|
|
address referrer,
|
|
uint deadline
|
|
) external returns (uint[] memory amounts);
|
|
|
|
function getAmountsOut(uint amountIn, address[] calldata path)
|
|
external view returns (uint[] memory amounts);
|
|
}
|
|
|
|
/**
|
|
* @title ProductionArbitrageExecutor
|
|
* @dev PRODUCTION-GRADE arbitrage executor for profitable MEV extraction
|
|
* @notice This contract executes flash swap arbitrage between DEXes on Arbitrum
|
|
*/
|
|
contract ProductionArbitrageExecutor is ReentrancyGuard, Ownable {
|
|
using SafeERC20 for IERC20;
|
|
|
|
// Router addresses on Arbitrum
|
|
IUniswapV3Router public constant UNISWAP_V3_ROUTER =
|
|
IUniswapV3Router(0xE592427A0AEce92De3Edee1F18E0157C05861564);
|
|
ICamelotRouter public constant CAMELOT_ROUTER =
|
|
ICamelotRouter(0xc873fEcbd354f5A56E00E710B90EF4201db2448d);
|
|
|
|
// Common token addresses on Arbitrum
|
|
address public constant WETH = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;
|
|
address public constant USDC = 0xaF88d065e77c8cC2239327C5EDb3A432268e5831;
|
|
address public constant USDT = 0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9;
|
|
address public constant ARB = 0x912CE59144191C1204E64559FE8253a0e49E6548;
|
|
|
|
// Minimum profit threshold (in wei)
|
|
uint256 public minProfitThreshold = 0.005 ether; // 0.005 ETH minimum profit
|
|
|
|
// Maximum gas price for profitable execution
|
|
uint256 public maxGasPrice = 5 gwei; // 5 gwei max
|
|
|
|
// Events for tracking profitable arbitrage
|
|
event ArbitrageExecuted(
|
|
address indexed tokenA,
|
|
address indexed tokenB,
|
|
uint256 amountIn,
|
|
uint256 profit,
|
|
uint256 gasUsed
|
|
);
|
|
|
|
event ProfitWithdrawn(address indexed token, uint256 amount);
|
|
|
|
struct ArbitrageParams {
|
|
address tokenA;
|
|
address tokenB;
|
|
uint256 amountIn;
|
|
uint24 uniswapFee;
|
|
address[] camelotPath;
|
|
uint256 minProfit;
|
|
bool buyOnUniswap; // true = buy on Uniswap, sell on Camelot
|
|
}
|
|
|
|
/**
|
|
* @dev Execute profitable arbitrage using flash swap
|
|
* @param pool Uniswap V3 pool to flash swap from
|
|
* @param params Arbitrage parameters encoded as bytes
|
|
*/
|
|
function executeArbitrage(address pool, bytes calldata params) external onlyOwner {
|
|
require(tx.gasprice <= maxGasPrice, "Gas price too high for profit");
|
|
|
|
ArbitrageParams memory arbParams = abi.decode(params, (ArbitrageParams));
|
|
|
|
// Validate minimum profit potential
|
|
uint256 estimatedProfit = estimateProfit(arbParams);
|
|
require(estimatedProfit >= minProfitThreshold, "Insufficient profit potential");
|
|
|
|
// Calculate optimal flash amount
|
|
uint256 flashAmount = calculateOptimalAmount(arbParams);
|
|
|
|
// Prepare flash swap data
|
|
bytes memory flashData = abi.encode(arbParams, block.timestamp);
|
|
|
|
// Execute flash swap
|
|
if (arbParams.tokenA == IUniswapV3Pool(pool).token0()) {
|
|
IUniswapV3Pool(pool).flash(address(this), flashAmount, 0, flashData);
|
|
} else {
|
|
IUniswapV3Pool(pool).flash(address(this), 0, flashAmount, flashData);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Uniswap V3 flash callback - executes the arbitrage logic
|
|
*/
|
|
function uniswapV3FlashCallback(
|
|
uint256 fee0,
|
|
uint256 fee1,
|
|
bytes calldata data
|
|
) external {
|
|
uint256 gasStart = gasleft();
|
|
|
|
(ArbitrageParams memory params, uint256 deadline) = abi.decode(data, (ArbitrageParams, uint256));
|
|
|
|
// Validate callback is from legitimate pool
|
|
require(isValidPool(msg.sender, params.tokenA, params.tokenB), "Invalid pool");
|
|
require(block.timestamp <= deadline + 300, "Transaction too old");
|
|
|
|
uint256 amountOwed = params.tokenA == IUniswapV3Pool(msg.sender).token0() ?
|
|
params.amountIn + fee0 : params.amountIn + fee1;
|
|
|
|
// Execute arbitrage strategy
|
|
uint256 profit = executeArbitrageStrategy(params, amountOwed);
|
|
|
|
// Ensure we made profit after repaying flash loan
|
|
require(profit >= minProfitThreshold, "Arbitrage not profitable");
|
|
|
|
// Repay flash loan
|
|
IERC20(params.tokenA).safeTransfer(msg.sender, amountOwed);
|
|
|
|
// Calculate gas cost in tokens
|
|
uint256 gasUsed = gasStart - gasleft();
|
|
|
|
emit ArbitrageExecuted(params.tokenA, params.tokenB, params.amountIn, profit, gasUsed);
|
|
}
|
|
|
|
/**
|
|
* @dev Execute the actual arbitrage strategy
|
|
*/
|
|
function executeArbitrageStrategy(ArbitrageParams memory params, uint256 amountOwed)
|
|
private returns (uint256 profit) {
|
|
|
|
uint256 startBalance = IERC20(params.tokenA).balanceOf(address(this));
|
|
|
|
if (params.buyOnUniswap) {
|
|
// Buy tokenB on Uniswap, sell on Camelot
|
|
uint256 amountOut = buyOnUniswap(params);
|
|
uint256 finalAmount = sellOnCamelot(params.tokenB, params.tokenA, amountOut, params.camelotPath);
|
|
|
|
uint256 endBalance = IERC20(params.tokenA).balanceOf(address(this));
|
|
profit = endBalance > startBalance + amountOwed ?
|
|
endBalance - startBalance - amountOwed : 0;
|
|
} else {
|
|
// Buy tokenB on Camelot, sell on Uniswap
|
|
uint256 amountOut = buyOnCamelot(params);
|
|
uint256 finalAmount = sellOnUniswap(params.tokenB, params.tokenA, amountOut, params.uniswapFee);
|
|
|
|
uint256 endBalance = IERC20(params.tokenA).balanceOf(address(this));
|
|
profit = endBalance > startBalance + amountOwed ?
|
|
endBalance - startBalance - amountOwed : 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Buy tokens on Uniswap V3
|
|
*/
|
|
function buyOnUniswap(ArbitrageParams memory params) private returns (uint256 amountOut) {
|
|
IERC20(params.tokenA).safeApprove(address(UNISWAP_V3_ROUTER), params.amountIn);
|
|
|
|
IUniswapV3Router.ExactInputSingleParams memory swapParams = IUniswapV3Router.ExactInputSingleParams({
|
|
tokenIn: params.tokenA,
|
|
tokenOut: params.tokenB,
|
|
fee: params.uniswapFee,
|
|
recipient: address(this),
|
|
deadline: block.timestamp + 300,
|
|
amountIn: params.amountIn,
|
|
amountOutMinimum: 0, // Will be calculated dynamically
|
|
sqrtPriceLimitX96: 0
|
|
});
|
|
|
|
amountOut = UNISWAP_V3_ROUTER.exactInputSingle(swapParams);
|
|
}
|
|
|
|
/**
|
|
* @dev Sell tokens on Uniswap V3
|
|
*/
|
|
function sellOnUniswap(address tokenIn, address tokenOut, uint256 amountIn, uint24 fee)
|
|
private returns (uint256 amountOut) {
|
|
|
|
IERC20(tokenIn).safeApprove(address(UNISWAP_V3_ROUTER), amountIn);
|
|
|
|
IUniswapV3Router.ExactInputSingleParams memory swapParams = IUniswapV3Router.ExactInputSingleParams({
|
|
tokenIn: tokenIn,
|
|
tokenOut: tokenOut,
|
|
fee: fee,
|
|
recipient: address(this),
|
|
deadline: block.timestamp + 300,
|
|
amountIn: amountIn,
|
|
amountOutMinimum: 0,
|
|
sqrtPriceLimitX96: 0
|
|
});
|
|
|
|
amountOut = UNISWAP_V3_ROUTER.exactInputSingle(swapParams);
|
|
}
|
|
|
|
/**
|
|
* @dev Buy tokens on Camelot
|
|
*/
|
|
function buyOnCamelot(ArbitrageParams memory params) private returns (uint256 amountOut) {
|
|
IERC20(params.tokenA).safeApprove(address(CAMELOT_ROUTER), params.amountIn);
|
|
|
|
uint256[] memory amounts = CAMELOT_ROUTER.swapExactTokensForTokens(
|
|
params.amountIn,
|
|
0, // amountOutMin - calculated dynamically
|
|
params.camelotPath,
|
|
address(this),
|
|
address(0), // referrer
|
|
block.timestamp + 300
|
|
);
|
|
|
|
amountOut = amounts[amounts.length - 1];
|
|
}
|
|
|
|
/**
|
|
* @dev Sell tokens on Camelot
|
|
*/
|
|
function sellOnCamelot(address tokenIn, address tokenOut, uint256 amountIn, address[] memory path)
|
|
private returns (uint256 amountOut) {
|
|
|
|
IERC20(tokenIn).safeApprove(address(CAMELOT_ROUTER), amountIn);
|
|
|
|
uint256[] memory amounts = CAMELOT_ROUTER.swapExactTokensForTokens(
|
|
amountIn,
|
|
0,
|
|
path,
|
|
address(this),
|
|
address(0),
|
|
block.timestamp + 300
|
|
);
|
|
|
|
amountOut = amounts[amounts.length - 1];
|
|
}
|
|
|
|
/**
|
|
* @dev Estimate profit for given arbitrage parameters
|
|
*/
|
|
function estimateProfit(ArbitrageParams memory params) public view returns (uint256 profit) {
|
|
// This is a simplified estimation - in production you'd use more sophisticated pricing
|
|
try CAMELOT_ROUTER.getAmountsOut(params.amountIn, params.camelotPath) returns (uint256[] memory amounts) {
|
|
uint256 camelotOutput = amounts[amounts.length - 1];
|
|
|
|
// Estimate Uniswap output (simplified)
|
|
uint256 uniswapOutput = params.amountIn * 995 / 1000; // Rough estimate with 0.5% slippage
|
|
|
|
if (params.buyOnUniswap && camelotOutput > params.amountIn) {
|
|
profit = camelotOutput - params.amountIn;
|
|
} else if (!params.buyOnUniswap && uniswapOutput > params.amountIn) {
|
|
profit = uniswapOutput - params.amountIn;
|
|
}
|
|
|
|
// Subtract estimated gas costs (0.002 ETH equivalent)
|
|
uint256 gasCostInToken = 0.002 ether; // Rough estimate
|
|
profit = profit > gasCostInToken ? profit - gasCostInToken : 0;
|
|
} catch {
|
|
profit = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Calculate optimal flash swap amount for maximum profit
|
|
*/
|
|
function calculateOptimalAmount(ArbitrageParams memory params) public view returns (uint256) {
|
|
// Start with base amount and find optimal size
|
|
uint256 baseAmount = 1 ether; // 1 token base
|
|
uint256 maxProfit = 0;
|
|
uint256 optimalAmount = baseAmount;
|
|
|
|
// Test different amounts to find optimal
|
|
for (uint256 multiplier = 1; multiplier <= 10; multiplier++) {
|
|
uint256 testAmount = baseAmount * multiplier;
|
|
ArbitrageParams memory testParams = params;
|
|
testParams.amountIn = testAmount;
|
|
|
|
uint256 estimatedProfit = estimateProfit(testParams);
|
|
if (estimatedProfit > maxProfit && estimatedProfit >= minProfitThreshold) {
|
|
maxProfit = estimatedProfit;
|
|
optimalAmount = testAmount;
|
|
}
|
|
}
|
|
|
|
return optimalAmount;
|
|
}
|
|
|
|
/**
|
|
* @dev Validate that the callback is from a legitimate Uniswap V3 pool
|
|
*/
|
|
function isValidPool(address pool, address tokenA, address tokenB) private view returns (bool) {
|
|
try IUniswapV3Pool(pool).token0() returns (address token0) {
|
|
try IUniswapV3Pool(pool).token1() returns (address token1) {
|
|
return (token0 == tokenA && token1 == tokenB) || (token0 == tokenB && token1 == tokenA);
|
|
} catch {
|
|
return false;
|
|
}
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Withdraw accumulated profits
|
|
*/
|
|
function withdrawProfits(address token) external onlyOwner {
|
|
uint256 balance = IERC20(token).balanceOf(address(this));
|
|
require(balance > 0, "No profits to withdraw");
|
|
|
|
IERC20(token).safeTransfer(owner(), balance);
|
|
emit ProfitWithdrawn(token, balance);
|
|
}
|
|
|
|
/**
|
|
* @dev Emergency withdrawal function
|
|
*/
|
|
function emergencyWithdraw(address token, uint256 amount) external onlyOwner {
|
|
IERC20(token).safeTransfer(owner(), amount);
|
|
}
|
|
|
|
/**
|
|
* @dev Update minimum profit threshold
|
|
*/
|
|
function setMinProfitThreshold(uint256 _minProfitThreshold) external onlyOwner {
|
|
minProfitThreshold = _minProfitThreshold;
|
|
}
|
|
|
|
/**
|
|
* @dev Update maximum gas price
|
|
*/
|
|
function setMaxGasPrice(uint256 _maxGasPrice) external onlyOwner {
|
|
maxGasPrice = _maxGasPrice;
|
|
}
|
|
|
|
/**
|
|
* @dev Receive ETH
|
|
*/
|
|
receive() external payable {}
|
|
} |