메뉴
Production-ready DeFi arbitrage system that detects and executes profitable price differences across multiple DEXs using Aave V3 flash loans. Real smart contract integration with Uniswap V3, Curve, and SushiSwap.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/XSpoonAi/spoon-awesome-skill --skill flash-loan-arbitrage-executor명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SOC 직업 분류 기준
SKILL.md 표시 중
| name | Flash Loan Arbitrage Executor |
| description | Production-ready DeFi arbitrage system that detects and executes profitable price differences across multiple DEXs using Aave V3 flash loans. Real smart contract integration with Uniswap V3, Curve, and SushiSwap. |
| version | 1.0.0 |
| author | Sambit (Community Contributor) |
| tags | ["web3-core-operations","defi","flash-loans","arbitrage","smart-contracts","uniswap","curve","aave"] |
| category | Web3 Core Operations |
| difficulty | Advanced |
| estimated_time | 45-90 minutes |
| last_updated | 2026-02-19T00:00:00.000Z |
| activation_triggers | ["flash loan arbitrage","detect arbitrage opportunities","execute flash loans","DEX arbitrage","price difference trading","multi-dex arbitrage","profitable arbitrage","aave flash loans"] |
| parameters | [{"name":"min_profit_threshold","type":"float","default":0.3,"description":"Minimum profit percentage required to execute arbitrage (default 0.3%)"},{"name":"rpc_url","type":"str","required":true,"description":"Ethereum RPC endpoint (recommended: Alchemy or Infura for production)"},{"name":"private_key","type":"str","required":false,"description":"Private key for transaction execution (optional - omit for read-only mode)"},{"name":"chain","type":"str","default":"ethereum","description":"Blockchain network (ethereum, polygon, arbitrum, optimism)"},{"name":"max_trade_size","type":"float","default":100000,"description":"Maximum trade size in USD (default $100,000)"}] |
| dependencies | ["web3==7.6.0","requests==2.31.0","dataclasses (builtin)"] |
| api_requirements | [{"name":"Ethereum RPC","required":true,"free_tier":false,"description":"Full archive node recommended for production (Alchemy/Infura)","signup_url":"https://www.alchemy.com/"},{"name":"1inch API","required":false,"free_tier":true,"description":"For Uniswap price quotes (fallback method)","signup_url":"https://portal.1inch.dev/"}] |
| environment_variables | {"PRIVATE_KEY":"Required for live trading (NEVER commit to git)","RPC_URL":"Ethereum RPC endpoint (use private RPC for production)"} |
| supported_chains | ["Ethereum (primary)","Polygon","Arbitrum","Optimism"] |
| use_cases | ["Capture price inefficiencies across DEXs","Execute zero-capital arbitrage trades","Learn flash loan mechanics hands-on","Research MEV (Maximal Extractable Value)","Automated profit extraction from DeFi"] |
| expected_output | ["List of profitable arbitrage opportunities with net profit estimates","Real-time price data from Uniswap V3, Curve, SushiSwap","Transaction simulation with gas cost breakdowns","Executable flash loan transactions (with private key)","Profit/loss reports and analytics"] |
The Flash Loan Arbitrage Executor is a production-ready DeFi system that identifies and executes profitable arbitrage opportunities across multiple decentralized exchanges (DEXs) using Aave V3 flash loans.
Core Value Proposition: Execute arbitrage trades with ZERO upfront capital using flash loans.
This skill uses 100% real smart contract interactions:
Real Arbitrage Detection
Flash Loan Integration
Production Safety
Smart Contract Operations
get_dy function)quoteExactInputSingle)flash-loan-arbitrage/
├── scripts/
│ ├── arbitrage_finder.py # Opportunity detection
│ ├── flash_loan_executor.py # Flash loan execution
│ └── dex_swapper.py # DEX swap handlers
├── SKILL.md # This file
├── README.md # Quick start guide
└── PULL.md # Test results
1. Arbitrage Detection
├─> Fetch prices from all DEXs
├─> Compare buy/sell prices
├─> Calculate profit potential
└─> Filter by minimum threshold
2. Opportunity Validation
├─> Check liquidity sufficiency
├─> Estimate gas costs
├─> Calculate optimal trade size
└─> Verify net profitability
3. Flash Loan Execution
├─> Borrow tokens from Aave
├─> Buy tokens on cheaper DEX
├─> Sell tokens on expensive DEX
└─> Repay flash loan + fees
4. Profit Extraction
├─> Calculate actual profit
├─> Deduct gas costs
└─> Transfer profit to wallet
# Python 3.8 or higher
python3 --version
# web3.py library
pip install web3
# requests library
pip install requests
git clone <repository-url>
cd web3-core-operations/flash-loan-arbitrage
pip install -r requirements.txt
# Use a reliable RPC provider
RPC_URL = "https://eth.llamarpc.com" # Public
# Or use Alchemy/Infura for production
RPC_URL = "https://eth-mainnet.alchemyapi.io/v2/YOUR_KEY"
# NEVER commit private keys to git
PRIVATE_KEY = os.environ.get("PRIVATE_KEY")
from arbitrage_finder import ArbitrageFinder
# Initialize finder
finder = ArbitrageFinder(min_profit_threshold=0.3)
# Scan for opportunities
opportunities = finder.find_opportunities()
# Display top opportunities
for opp in opportunities[:5]:
print(f"{opp.token_in}/{opp.token_out}")
print(f" Buy on {opp.buy_dex} @ ${opp.buy_price:.4f}")
print(f" Sell on {opp.sell_dex} @ ${opp.sell_price:.4f}")
print(f" Net Profit: ${opp.net_profit_estimate:.2f}")
print(f" ROI: {(opp.net_profit_estimate / opp.optimal_amount * 100):.2f}%\n")
from flash_loan_executor import FlashLoanExecutor
# Initialize executor (no private key = simulation only)
executor = FlashLoanExecutor(
rpc_url="https://eth.llamarpc.com",
chain="ethereum"
)
# Simulate the best opportunity
if opportunities:
best_opp = opportunities[0]
result = executor.simulate_arbitrage(best_opp)
print(f"Simulated Net Profit: ${result['net_profit']:.2f}")
print(f"ROI: {result['roi_percent']:.2f}%")
⚠️ WARNING: This requires real funds and involves financial risk
# Initialize with private key for real execution
executor = FlashLoanExecutor(
rpc_url="https://eth.llamarpc.com",
private_key=os.environ.get("PRIVATE_KEY"),
chain="ethereum"
)
# Token addresses mapping
token_addresses = {
"WETH": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
"USDC": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
"USDT": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
# ... other tokens
}
# Execute arbitrage (dry_run=False for real execution)
result = executor.execute_flash_loan_arbitrage(
opportunity=best_opp,
token_addresses=token_addresses,
dry_run=False # Set to True to simulate
)
if result['success']:
print(f"✅ Arbitrage executed successfully!")
print(f"Transaction: {result['tx_hash']}")
else:
print(f"❌ Execution failed: {result['error']}")
| DEX | Type | Pool Fees | Use Case |
|---|---|---|---|
| Uniswap V3 | AMM | 0.01% - 1% | General pairs, concentrated liquidity |
| SushiSwap | AMM | 0.3% | Wide token selection |
| Curve | Stableswap | 0.04% | Stablecoin pairs (best rates) |
| Balancer | Weighted pools | 0.01% - 10% | Multi-token pools |
| Provider | Fee | Chains | Max Loan |
|---|---|---|---|
| Aave V3 | 0.09% | ETH, Polygon, Arbitrum, Optimism | Depends on liquidity |
Typical gas costs for flash loan arbitrage:
At 30 gwei and $2,800 ETH price:
Gas Cost = (350,000 * 30 / 10^9) * $2,800 = ~$84
# Gross profit from price spread
gross_profit = (sell_price - buy_price) * amount
# Flash loan fee (Aave = 0.09%)
flash_loan_fee = amount * 0.0009
# Gas cost
gas_cost = gas_units * gas_price * eth_price
# Net profit
net_profit = gross_profit - flash_loan_fee - gas_cost
# Only execute if net_profit > 0
The finder monitors these pairs by default:
# Set minimum profit percentage to filter opportunities
MIN_PROFIT_THRESHOLD = 0.3 # 0.3% minimum profit
finder = ArbitrageFinder(min_profit_threshold=MIN_PROFIT_THRESHOLD)
# Configure trade size constraints
MAX_TRADE_SIZE = 100000 # $100,000 max per trade
LIQUIDITY_USAGE_PERCENT = 10 # Use max 10% of available liquidity
# Optimal trade size calculation
optimal_size = min(
MAX_TRADE_SIZE,
liquidity_usd * (LIQUIDITY_USAGE_PERCENT / 100)
)
# Set slippage tolerance for swaps
SLIPPAGE_PERCENT = 0.5 # 0.5% slippage tolerance
# Calculate minimum output
min_amount_out = expected_output * (1 - SLIPPAGE_PERCENT / 100)
# Use current network gas price
gas_price = w3.eth.gas_price
# Or set custom gas price (in gwei)
custom_gas_price = w3.to_wei(30, 'gwei')
| Risk | Description | Mitigation |
|---|---|---|
| Frontrunning | MEV bots may copy your trade | Use private mempools (Flashbots) |
| Price Impact | Large trades can move prices | Limit trade size to 10% of liquidity |
| Failed Transactions | Transaction may revert | Simulate before execution |
| High Gas Costs | Gas spikes can eliminate profit | Monitor gas prices, set max gas |
| Smart Contract Risk | DEX contracts may have bugs | Use audited DEXs only |
Issue: "Insufficient liquidity" error
# Solution: Reduce trade size
optimal_amount = min(
optimal_amount,
liquidity_usd * 0.05 # Use only 5% of liquidity
)
Issue: "Transaction reverted" error
# Solution: Check slippage tolerance
slippage_percent = 1.0 # Increase to 1%
Issue: "RPC rate limit exceeded"
# Solution: Add delays between requests
import time
time.sleep(0.2) # 200ms delay between API calls
Issue: "Gas estimation failed"
# Solution: Set manual gas limit
gas_limit = 500000 # Increase gas limit
# Add custom trading pairs
custom_pairs = [
("LINK", "WETH"),
("UNI", "USDC"),
("AAVE", "WETH")
]
finder.trading_pairs.extend(custom_pairs)
# Execute arbitrage across 3+ DEXs
# Example: Buy on Uniswap → Sell on Curve → Sell on SushiSwap
# This requires more complex routing logic
# Use Flashbots to avoid frontrunning
flashbots_url = "https://relay.flashbots.net"
# Send bundle instead of regular transaction
bundle = [
{"tx": signed_tx1},
{"tx": signed_tx2}
]
class ArbitrageFinder:
def __init__(self, min_profit_threshold: float = 0.3)
def find_opportunities(self) -> List[ArbitrageOpportunity]
def get_all_dex_prices(self, token_in: str, token_out: str) -> Dict
def calculate_arbitrage_profit(self, buy_price: float, sell_price: float,
amount: float, gas_cost: float) -> Dict
class FlashLoanExecutor:
def __init__(self, rpc_url: str, private_key: Optional[str], chain: str)
def simulate_arbitrage(self, opportunity: ArbitrageOpportunity) -> Dict
def execute_flash_loan_arbitrage(self, opportunity: ArbitrageOpportunity,
token_addresses: Dict, dry_run: bool) -> Dict
def estimate_gas_cost(self) -> Dict
class DexSwapper:
def __init__(self, w3: Web3, account_address: Optional[str])
def execute_swap(self, dex: str, token_in: str, token_out: str,
amount_in: int, slippage_percent: float) -> Dict
def simulate_swap(self, dex: str, token_in: str, token_out: str,
amount_in: float) -> Dict
MIT License - See repository root for details
⚠️ IMPORTANT: This tool is for educational purposes. Flash loan arbitrage involves significant financial risk. Always:
The developers are not responsible for any financial losses incurred through use of this tool.