@intentsolutionsio/flash-loan-simulator 1.0.0 → 1.0.8

package/skills/simulating-flash-loans/scripts/formatters.py

@@ -9,13 +9,12 @@ Handles all output formatting:
 """
 
 import json
-from dataclasses import asdict
 from decimal import Decimal
-from typing import Any, Dict, List, Optional
+from typing import List, Optional
 
-from strategy_engine import StrategyResult, TransactionStep, StrategyType
-from profit_calculator import ProfitBreakdown, GasEstimate
-from risk_assessor import RiskAssessment, RiskFactor, RiskLevel
+from strategy_engine import StrategyResult, StrategyType
+from profit_calculator import ProfitBreakdown
+from risk_assessor import RiskAssessment, RiskLevel
 from protocol_adapters import ProviderInfo
 
 
@@ -79,8 +78,7 @@ class ConsoleFormatter:
             border_left = (inner_width - len(title_part)) // 2
             border_right = inner_width - len(title_part) - border_left
             result.append(
-                f"{self.BOX_TL}{self.BOX_H * border_left}{title_part}"
-                f"{self.BOX_H * border_right}{self.BOX_TR}"
+                f"{self.BOX_TL}{self.BOX_H * border_left}{title_part}{self.BOX_H * border_right}{self.BOX_TR}"
             )
         else:
             result.append(f"{self.BOX_TL}{self.BOX_H * (inner_width + 2)}{self.BOX_TR}")
@@ -126,14 +124,9 @@ class ConsoleFormatter:
         lines.append(self._subheader("PROFIT BREAKDOWN"))
         lines.append(f"  Gross Profit:  {result.gross_profit:+.6f} {result.loan_asset}")
         lines.append(f"  Flash Loan Fee: -{result.loan_fee:.6f} {result.loan_asset}")
-        lines.append(
-            f"  Gas Cost:       -{result.gas_cost_eth:.6f} ETH (${result.gas_cost_usd:.2f})"
-        )
+        lines.append(f"  Gas Cost:       -{result.gas_cost_eth:.6f} ETH (${result.gas_cost_usd:.2f})")
         lines.append(f"  {'-' * 40}")
-        lines.append(
-            f"  Net Profit:    {result.net_profit:+.6f} {result.loan_asset} "
-            f"(${result.net_profit_usd:+.2f})"
-        )
+        lines.append(f"  Net Profit:    {result.net_profit:+.6f} {result.loan_asset} (${result.net_profit_usd:+.2f})")
         lines.append(f"  ROI:           {result.roi_percent:.4f}%")
 
         return "\n".join(lines)
@@ -150,20 +143,14 @@ class ConsoleFormatter:
         # Costs
         lines.append("\n  Costs:")
         lines.append(f"    Flash Loan Fee: -{breakdown.flash_loan_fee:.6f} ETH")
-        lines.append(
-            f"    Gas Cost:       -{breakdown.gas_cost_eth:.6f} ETH "
-            f"(${breakdown.gas_cost_usd:.2f})"
-        )
+        lines.append(f"    Gas Cost:       -{breakdown.gas_cost_eth:.6f} ETH (${breakdown.gas_cost_usd:.2f})")
         lines.append(f"    Est. Slippage:  -{breakdown.slippage_cost:.6f} ETH")
         lines.append(f"    DEX Fees:       ~{breakdown.dex_fees:.6f} ETH (in price)")
         lines.append(f"    {'-' * 45}")
         lines.append(f"    Total Costs:    -{breakdown.total_costs:.6f} ETH")
 
         # Net
-        lines.append(
-            f"\n  Net Profit: {breakdown.net_profit:+.6f} ETH "
-            f"(${breakdown.net_profit_usd:+.2f})"
-        )
+        lines.append(f"\n  Net Profit: {breakdown.net_profit:+.6f} ETH (${breakdown.net_profit_usd:+.2f})")
         lines.append(f"  ROI: {breakdown.roi_percent:.4f}%")
         lines.append(f"  Breakeven Gas: {breakdown.breakeven_gas_price:.1f} gwei")
 
@@ -182,9 +169,7 @@ class ConsoleFormatter:
         lines.append(self._header("RISK ASSESSMENT"))
 
         # Overall rating
-        indicator, label = self.RISK_INDICATORS.get(
-            assessment.overall_level, ("⚪", "UNKNOWN")
-        )
+        indicator, label = self.RISK_INDICATORS.get(assessment.overall_level, ("⚪", "UNKNOWN"))
         lines.append(f"\n  Overall Risk: {indicator} {label}")
         lines.append(f"  Risk Score: {assessment.overall_score:.0f}/100")
         lines.append(f"  Viability: {assessment.viability}")
@@ -211,9 +196,7 @@ class ConsoleFormatter:
 
         return "\n".join(lines)
 
-    def format_provider_comparison(
-        self, providers: List[ProviderInfo], asset: str, amount: Decimal
-    ) -> str:
+    def format_provider_comparison(self, providers: List[ProviderInfo], asset: str, amount: Decimal) -> str:
         """Format provider comparison table."""
         lines = []
 
@@ -221,10 +204,7 @@ class ConsoleFormatter:
         lines.append(f"\n  Comparing {amount} {asset} flash loan:\n")
 
         # Table header
-        lines.append(
-            f"  {'Provider':<14} {'Fee %':<8} {'Fee Amount':<14} "
-            f"{'Gas OH':<10} {'Chains':<20}"
-        )
+        lines.append(f"  {'Provider':<14} {'Fee %':<8} {'Fee Amount':<14} {'Gas OH':<10} {'Chains':<20}")
         lines.append(f"  {'-' * 66}")
 
         # Table rows
@@ -236,10 +216,7 @@ class ConsoleFormatter:
             if len(info.supported_chains) > 2:
                 chains += "..."
 
-            lines.append(
-                f"  {info.name:<14} {fee_pct:<8} {fee_amt:<14} "
-                f"{gas_oh:<10} {chains:<20}"
-            )
+            lines.append(f"  {info.name:<14} {fee_pct:<8} {fee_amt:<14} {gas_oh:<10} {chains:<20}")
 
         # Recommendation
         if providers:
@@ -252,17 +229,14 @@ class ConsoleFormatter:
 
         return "\n".join(lines)
 
-    def format_quick_summary(
-        self, result: StrategyResult, assessment: Optional[RiskAssessment] = None
-    ) -> str:
+    def format_quick_summary(self, result: StrategyResult, assessment: Optional[RiskAssessment] = None) -> str:
         """Format a quick one-box summary."""
         lines = []
 
         # Profit line
         profit_emoji = "✓" if result.is_profitable else "✗"
         lines.append(
-            f"Net Profit: {result.net_profit:+.6f} {result.loan_asset} "
-            f"(${result.net_profit_usd:+.2f}) {profit_emoji}"
+            f"Net Profit: {result.net_profit:+.6f} {result.loan_asset} (${result.net_profit_usd:+.2f}) {profit_emoji}"
         )
 
         # Provider
@@ -270,15 +244,11 @@ class ConsoleFormatter:
 
         # Risk if available
         if assessment:
-            ind, lbl = self.RISK_INDICATORS.get(
-                assessment.overall_level, ("⚪", "?")
-            )
+            ind, lbl = self.RISK_INDICATORS.get(assessment.overall_level, ("⚪", "?"))
             lines.append(f"Risk: {ind} {lbl} | Viability: {assessment.viability}")
 
         # Verdict
-        if result.is_profitable and (
-            assessment is None or assessment.viability != "NO-GO"
-        ):
+        if result.is_profitable and (assessment is None or assessment.viability != "NO-GO"):
             lines.append("Verdict: PROCEED WITH CAUTION")
         elif result.is_profitable:
             lines.append("Verdict: HIGH RISK - RECONSIDER")
@@ -400,9 +370,7 @@ class MarkdownFormatter:
         lines.append(f"- **Strategy**: {result.strategy_type.value}")
         lines.append(f"- **Loan**: {result.loan_amount} {result.loan_asset}")
         lines.append(f"- **Provider**: {result.provider}")
-        lines.append(
-            f"- **Profitable**: {'Yes ✓' if result.is_profitable else 'No ✗'}"
-        )
+        lines.append(f"- **Profitable**: {'Yes ✓' if result.is_profitable else 'No ✗'}")
         lines.append("")
 
         # Profit
@@ -461,7 +429,7 @@ class MarkdownFormatter:
 
 def demo():
     """Demonstrate formatters."""
-    from strategy_engine import StrategyFactory, StrategyType, ArbitrageParams
+    from strategy_engine import StrategyFactory, ArbitrageParams
     from profit_calculator import ProfitCalculator
     from risk_assessor import RiskAssessor
     from protocol_adapters import ProviderManager

package/skills/simulating-flash-loans/scripts/profit_calculator.py

@@ -11,7 +11,7 @@ Calculates net profit after all costs including:
 
 from dataclasses import dataclass
 from decimal import Decimal
-from typing import List, Optional
+from typing import List
 
 from strategy_engine import StrategyResult, TransactionStep
 
@@ -120,9 +120,7 @@ class ProfitCalculator:
         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)
-            )
+            breakeven_gas = float(profit_before_gas * Decimal("1e9") / (total_gas_units * self.eth_price_usd))
         else:
             breakeven_gas = 0.0
 
@@ -223,15 +221,17 @@ class ProfitCalculator:
 
             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),
-            })
+            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"])
@@ -267,11 +267,11 @@ def demo():
     print("=" * 60)
 
     print(f"\nGross Revenue: {breakdown.gross_revenue:.6f} ETH")
-    print(f"\nCosts:")
+    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(f"  ────────────────────────────────")
+    print("  ────────────────────────────────")
     print(f"  Total Costs: -{breakdown.total_costs:.6f} ETH")
 
     print(f"\nNet Profit: {breakdown.net_profit:.6f} ETH (${breakdown.net_profit_usd:.2f})")
@@ -297,7 +297,7 @@ def demo():
         providers=providers,
     )
 
-    print(f"\nFor 100 ETH flash loan:")
+    print("\nFor 100 ETH flash loan:")
     print(f"{'Provider':<12} {'Fee %':<8} {'Fee ETH':<12} {'Gas ETH':<12} {'Total':<12}")
     print("-" * 56)
 

package/skills/simulating-flash-loans/scripts/protocol_adapters.py

@@ -11,8 +11,6 @@ from dataclasses import dataclass
 from decimal import Decimal
 from typing import Dict, List, Optional
 
-import httpx
-
 
 @dataclass
 class LoanParams:
@@ -343,9 +341,7 @@ class ProviderManager:
         """List all available providers."""
         return list(self.providers.keys())
 
-    def compare_providers(
-        self, asset: str, amount: Decimal, chain: str = "ethereum"
-    ) -> List[ProviderInfo]:
+    def compare_providers(self, asset: str, amount: Decimal, chain: str = "ethereum") -> List[ProviderInfo]:
         """
         Compare all providers for a specific loan.
 
@@ -368,9 +364,7 @@ class ProviderManager:
         results.sort(key=lambda x: x.fee_amount)
         return results
 
-    def find_cheapest(
-        self, asset: str, amount: Decimal, chain: str = "ethereum"
-    ) -> Optional[ProviderInfo]:
+    def find_cheapest(self, asset: str, amount: Decimal, chain: str = "ethereum") -> Optional[ProviderInfo]:
         """Find the cheapest provider for a loan."""
         providers = self.compare_providers(asset, amount, chain)
         return providers[0] if providers else None

package/skills/simulating-flash-loans/scripts/risk_assessor.py

@@ -12,7 +12,7 @@ Evaluates risks for flash loan strategies:
 from dataclasses import dataclass
 from decimal import Decimal
 from enum import Enum
-from typing import List, Optional
+from typing import List
 
 from strategy_engine import StrategyResult, StrategyType
 
@@ -128,10 +128,7 @@ class RiskAssessor:
             "Profit Margin": 0.15,
         }
 
-        overall_score = sum(
-            f.score * weights.get(f.name, 0.2)
-            for f in factors
-        )
+        overall_score = sum(f.score * weights.get(f.name, 0.2) for f in factors)
 
         # Determine overall level
         if overall_score < 30:
@@ -169,10 +166,7 @@ class RiskAssessor:
         # Higher score = more competition
         pair_key = (result.loan_asset, "USDC")  # Simplified
 
-        score = self.MEV_COMPETITION.get(
-            pair_key,
-            self.MEV_COMPETITION.get("default", 50)
-        )
+        score = self.MEV_COMPETITION.get(pair_key, self.MEV_COMPETITION.get("default", 50))
 
         # Adjust for trade size (larger = more attractive to MEV)
         if result.loan_amount > 100:
@@ -240,10 +234,7 @@ class RiskAssessor:
             protocols.add(step.protocol.lower())
 
         # Sum risk scores
-        total_risk = sum(
-            self.PROTOCOL_RISK.get(p, self.PROTOCOL_RISK["default"])
-            for p in protocols
-        )
+        total_risk = sum(self.PROTOCOL_RISK.get(p, self.PROTOCOL_RISK["default"]) for p in protocols)
 
         # Average across protocols
         score = total_risk / len(protocols) if protocols else 50
@@ -334,9 +325,7 @@ class RiskAssessor:
             mitigation="Increase trade size or wait for better opportunity",
         )
 
-    def _generate_recommendations(
-        self, factors: List[RiskFactor], result: StrategyResult
-    ) -> List[str]:
+    def _generate_recommendations(self, factors: List[RiskFactor], result: StrategyResult) -> List[str]:
         """Generate actionable recommendations."""
         recs = []
 
@@ -376,7 +365,7 @@ class RiskAssessor:
 
 def demo():
     """Demonstrate risk assessment."""
-    from strategy_engine import StrategyFactory, StrategyType, ArbitrageParams
+    from strategy_engine import StrategyFactory, ArbitrageParams
 
     # Run a simulation first
     factory = StrategyFactory()

package/skills/simulating-flash-loans/scripts/strategy_engine.py

@@ -176,9 +176,7 @@ class SimpleArbitrageStrategy(FlashLoanStrategy):
     def strategy_type(self) -> StrategyType:
         return StrategyType.SIMPLE_ARBITRAGE
 
-    def get_dex_price(
-        self, dex: str, from_token: str, to_token: str
-    ) -> Optional[Decimal]:
+    def get_dex_price(self, dex: str, from_token: str, to_token: str) -> Optional[Decimal]:
         """Get price from DEX (mock data)."""
         dex_prices = self.MOCK_PRICES.get(dex.lower(), {})
         return dex_prices.get((from_token.upper(), to_token.upper()))
@@ -219,9 +217,7 @@ class SimpleArbitrageStrategy(FlashLoanStrategy):
         )
 
         # Step 2: Sell on high-price DEX
-        sell_price = self.get_dex_price(
-            params.dex_sell, params.input_token, params.output_token
-        )
+        sell_price = self.get_dex_price(params.dex_sell, params.input_token, params.output_token)
         if not sell_price:
             warnings.append(f"No price data for {params.dex_sell}")
             sell_price = Decimal("2540")  # Fallback
@@ -245,9 +241,7 @@ class SimpleArbitrageStrategy(FlashLoanStrategy):
         )
 
         # Step 3: Buy on low-price DEX
-        buy_price = self.get_dex_price(
-            params.dex_buy, params.output_token, params.input_token
-        )
+        buy_price = self.get_dex_price(params.dex_buy, params.output_token, params.input_token)
         if not buy_price:
             warnings.append(f"No price data for {params.dex_buy}")
             buy_price = Decimal("1") / Decimal("2538")  # Fallback
@@ -389,11 +383,9 @@ class LiquidationStrategy(FlashLoanStrategy):
         debt_amount = Decimal("10000")  # 10K USDC debt
         collateral_amount = Decimal("5")  # 5 ETH collateral
         collateral_price = Decimal("2500")  # $2500/ETH
-        collateral_value = collateral_amount * collateral_price  # $12,500
+        collateral_amount * collateral_price  # $12,500
 
-        liquidation_bonus = self.LIQUIDATION_BONUSES.get(
-            params.protocol.lower(), Decimal("0.05")
-        )
+        liquidation_bonus = self.LIQUIDATION_BONUSES.get(params.protocol.lower(), Decimal("0.05"))
 
         # Step 1: Flash borrow debt asset
         loan_fee = provider.get_fee(params.debt_asset, debt_amount)
@@ -459,7 +451,7 @@ class LiquidationStrategy(FlashLoanStrategy):
                 output_amount=Decimal("0"),
                 fee=Decimal("0"),
                 gas_estimate=50000,
-                description=f"Repay flash loan",
+                description="Repay flash loan",
             )
         )