Skip to content

jeremylongshore/tons-of-skills-marketplace / plugins/crypto/flash-loan-simulator/skills/simulating-flash-loans

simulating-flash-loans

Verified

Simulate 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".

FileKindSize
ARD.mdmarkdown21.4 KB
PRD.mdmarkdown8.7 KB
SKILL.mdskill md4.5 KB
config/settings.yamlconfig9.4 KB
references/errors.mdmarkdown6.5 KB
references/examples.mdmarkdown15.0 KB
references/implementation.mdmarkdown2.9 KB
scripts/flash_simulator.pyscript14.6 KB
scripts/formatters.pyscript17.4 KB
scripts/profit_calculator.pyscript9.1 KB
scripts/protocol_adapters.pyscript11.9 KB
scripts/risk_assessor.pyscript12.9 KB
scripts/strategy_engine.pyscript18.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()
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: 198kUpdated Claude CodeCodexVerifiedInstall
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: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
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: 196kUpdated Claude CodeCodexVerifiedInstall