jeremylongshore/tons-of-skills-marketplace / plugins/crypto/flash-loan-simulator/skills/simulating-flash-loans
simulating-flash-loans
VerifiedSimulate flash loan strategies with profitability calculations and risk assessment across Aave, dYdX, and Balancer. Use when simulating flash loans, analyzing arbitrage profitability, evaluating liquidation opportunities, or comparing flash loan providers. Trigger with phrases like "simulate flash loan", "flash loan arbitrage", "liquidation profit", "compare Aave dYdX", "flash loan strategy", or "DeFi arbitrage simulation".
| File | Kind | Size |
|---|---|---|
| ARD.md | markdown | 21.4 KB |
| PRD.md | markdown | 8.7 KB |
| SKILL.md | skill md | 4.5 KB |
| config/settings.yaml | config | 9.4 KB |
| references/errors.md | markdown | 6.5 KB |
| references/examples.md | markdown | 15.0 KB |
| references/implementation.md | markdown | 2.9 KB |
| scripts/flash_simulator.py | script | 14.6 KB |
| scripts/formatters.py | script | 17.4 KB |
| scripts/profit_calculator.py | script | 9.1 KB |
| scripts/protocol_adapters.py | script | 11.9 KB |
| scripts/risk_assessor.py | script | 12.9 KB |
| scripts/strategy_engine.py | script | 18.8 KB |
scripts/profit_calculator.py
View on GitHub#!/usr/bin/env python3
"""
Flash loan profitability calculator.
Calculates net profit after all costs including:
- Flash loan fees
- Gas costs
- DEX fees (implicit in swaps)
- Slippage
"""
from dataclasses import dataclass
from decimal import Decimal
from typing import List
from strategy_engine import StrategyResult, TransactionStep
@dataclass
class ProfitBreakdown:
"""Detailed profit breakdown."""
gross_revenue: Decimal
flash_loan_fee: Decimal
gas_cost_eth: Decimal
gas_cost_usd: Decimal
dex_fees: Decimal
slippage_cost: Decimal
total_costs: Decimal
net_profit: Decimal
net_profit_usd: Decimal
roi_percent: float
breakeven_gas_price: float # Max gas price for profitability
is_profitable: bool
@dataclass
class GasEstimate:
"""Gas estimation for a transaction."""
gas_units: int
gas_price_gwei: float
cost_eth: Decimal
cost_usd: Decimal
class ProfitCalculator:
"""
Calculates detailed profitability for flash loan strategies.
Accounts for all costs and provides breakeven analysis.
"""
def __init__(
self,
eth_price_usd: float = 2500.0,
gas_price_gwei: float = 30.0,
):
"""
Initialize calculator.
Args:
eth_price_usd: Current ETH price
gas_price_gwei: Current gas price
"""
self.eth_price_usd = Decimal(str(eth_price_usd))
self.gas_price_gwei = gas_price_gwei
def calculate_breakdown(
self,
result: StrategyResult,
slippage_pct: float = 0.5,
) -> ProfitBreakdown:
"""
Calculate detailed profit breakdown from strategy result.
Args:
result: Strategy simulation result
slippage_pct: Expected slippage percentage
Returns:
Detailed profit breakdown
"""
# Calculate gross revenue (profit before any costs)
gross_revenue = result.gross_profit + result.loan_fee + result.gas_cost_eth
# Flash loan fee
flash_loan_fee = result.loan_fee
# Gas costs
gas_cost_eth = result.gas_cost_eth
gas_cost_usd = result.gas_cost_usd
# DEX fees (usually included in price, but track separately)
# Estimate ~0.3% per swap
num_swaps = sum(1 for s in result.steps if s.action == "swap")
dex_fee_rate = Decimal("0.003") # 0.3%
dex_fees = result.loan_amount * dex_fee_rate * num_swaps
# Slippage cost
slippage_rate = Decimal(str(slippage_pct / 100))
slippage_cost = result.loan_amount * slippage_rate
# Total costs
total_costs = flash_loan_fee + gas_cost_eth + slippage_cost
# Note: DEX fees already reflected in swap outputs
# Net profit
net_profit = result.net_profit
net_profit_usd = result.net_profit_usd
# ROI
roi = result.roi_percent
# Breakeven gas price
# At what gas price does profit = 0?
profit_before_gas = gross_revenue - flash_loan_fee - slippage_cost
total_gas_units = sum(s.gas_estimate for s in result.steps)
if total_gas_units > 0 and profit_before_gas > 0:
# profit_before_gas = gas_units * gas_price * eth_price
# gas_price = profit_before_gas / (gas_units * eth_price)
breakeven_gas = float(profit_before_gas * Decimal("1e9") / (total_gas_units * self.eth_price_usd))
else:
breakeven_gas = 0.0
return ProfitBreakdown(
gross_revenue=gross_revenue,
flash_loan_fee=flash_loan_fee,
gas_cost_eth=gas_cost_eth,
gas_cost_usd=gas_cost_usd,
dex_fees=dex_fees,
slippage_cost=slippage_cost,
total_costs=total_costs,
net_profit=net_profit,
net_profit_usd=net_profit_usd,
roi_percent=roi,
breakeven_gas_price=breakeven_gas,
is_profitable=net_profit > 0,
)
def estimate_gas(self, steps: List[TransactionStep]) -> GasEstimate:
"""
Estimate total gas cost for transaction steps.
Args:
steps: List of transaction steps
Returns:
Gas estimate with cost
"""
total_units = sum(s.gas_estimate for s in steps)
cost_eth = Decimal(total_units * self.gas_price_gwei) / Decimal("1e9")
cost_usd = cost_eth * self.eth_price_usd
return GasEstimate(
gas_units=total_units,
gas_price_gwei=self.gas_price_gwei,
cost_eth=cost_eth,
cost_usd=cost_usd,
)
def calculate_minimum_profit(
self,
loan_amount: Decimal,
loan_fee_rate: Decimal,
gas_units: int,
num_swaps: int = 2,
) -> Decimal:
"""
Calculate minimum profit needed to break even.
Useful for determining if an opportunity is worth pursuing.
"""
# Flash loan fee
loan_fee = loan_amount * loan_fee_rate
# Gas cost
gas_cost = Decimal(gas_units * self.gas_price_gwei) / Decimal("1e9")
# Minimum slippage assumption (0.5%)
slippage = loan_amount * Decimal("0.005")
return loan_fee + gas_cost + slippage
def compare_providers(
self,
loan_amount: Decimal,
asset: str,
gas_units: int,
providers: dict,
) -> List[dict]:
"""
Compare profitability across flash loan providers.
Args:
loan_amount: Amount to borrow
asset: Asset to borrow
gas_units: Base gas units (before provider overhead)
providers: Dict of provider name -> fee rate
Returns:
List of provider comparisons sorted by net cost
"""
results = []
for name, fee_rate in providers.items():
# Calculate fee
fee = loan_amount * Decimal(str(fee_rate))
# Estimate gas (with provider overhead)
overhead = {
"aave": 100000,
"dydx": 150000,
"balancer": 80000,
}.get(name.lower(), 100000)
total_gas = gas_units + overhead
gas_cost = Decimal(total_gas * self.gas_price_gwei) / Decimal("1e9")
total_cost = fee + gas_cost
results.append(
{
"provider": name,
"fee_rate": float(fee_rate) * 100,
"fee_amount": float(fee),
"gas_overhead": overhead,
"gas_cost_eth": float(gas_cost),
"total_cost_eth": float(total_cost),
"total_cost_usd": float(total_cost * self.eth_price_usd),
}
)
# Sort by total cost
results.sort(key=lambda x: x["total_cost_eth"])
return results
def demo():
"""Demonstrate profit calculator."""
from strategy_engine import StrategyFactory, StrategyType, ArbitrageParams
# Run a simulation first
factory = StrategyFactory()
strategy = factory.create(StrategyType.SIMPLE_ARBITRAGE)
params = ArbitrageParams(
input_token="ETH",
output_token="USDC",
amount=Decimal("100"),
dex_buy="sushiswap",
dex_sell="uniswap",
provider="aave",
)
result = strategy.simulate(params)
# Calculate detailed breakdown
calculator = ProfitCalculator(eth_price_usd=2500.0, gas_price_gwei=30.0)
breakdown = calculator.calculate_breakdown(result)
print("=" * 60)
print("PROFIT BREAKDOWN")
print("=" * 60)
print(f"\nGross Revenue: {breakdown.gross_revenue:.6f} ETH")
print("\nCosts:")
print(f" Flash Loan Fee: -{breakdown.flash_loan_fee:.6f} ETH")
print(f" Gas Cost: -{breakdown.gas_cost_eth:.6f} ETH (${breakdown.gas_cost_usd:.2f})")
print(f" Est. Slippage: -{breakdown.slippage_cost:.6f} ETH")
print(" ────────────────────────────────")
print(f" Total Costs: -{breakdown.total_costs:.6f} ETH")
print(f"\nNet Profit: {breakdown.net_profit:.6f} ETH (${breakdown.net_profit_usd:.2f})")
print(f"ROI: {breakdown.roi_percent:.4f}%")
print(f"Breakeven Gas: {breakdown.breakeven_gas_price:.1f} gwei")
print(f"\nProfitable: {'YES ✓' if breakdown.is_profitable else 'NO ✗'}")
# Compare providers
print("\n" + "=" * 60)
print("PROVIDER COMPARISON")
print("=" * 60)
providers = {
"Aave V3": 0.0009,
"dYdX": 0.0,
"Balancer": 0.0001,
}
comparisons = calculator.compare_providers(
loan_amount=Decimal("100"),
asset="ETH",
gas_units=300000,
providers=providers,
)
print("\nFor 100 ETH flash loan:")
print(f"{'Provider':<12} {'Fee %':<8} {'Fee ETH':<12} {'Gas ETH':<12} {'Total':<12}")
print("-" * 56)
for comp in comparisons:
print(
f"{comp['provider']:<12} "
f"{comp['fee_rate']:.2f}%{'':<4} "
f"{comp['fee_amount']:.4f}{'':<6} "
f"{comp['gas_cost_eth']:.4f}{'':<6} "
f"{comp['total_cost_eth']:.4f}"
)
if __name__ == "__main__":
demo()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |