refactor: move all remaining files to orig/ directory

Completed clean root directory structure:
- Root now contains only: .git, .env, docs/, orig/
- Moved all remaining files and directories to orig/:
  - Config files (.claude, .dockerignore, .drone.yml, etc.)
  - All .env variants (except active .env)
  - Git config (.gitconfig, .github, .gitignore, etc.)
  - Tool configs (.golangci.yml, .revive.toml, etc.)
  - Documentation (*.md files, @prompts)
  - Build files (Dockerfiles, Makefile, go.mod, go.sum)
  - Docker compose files
  - All source directories (scripts, tests, tools, etc.)
  - Runtime directories (logs, monitoring, reports)
  - Dependency files (node_modules, lib, cache)
  - Special files (--delete)

- Removed empty runtime directories (bin/, data/)

V2 structure is now clean:
- docs/planning/ - V2 planning documents
- orig/ - Complete V1 codebase preserved
- .env - Active environment config (not in git)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

orig/examples/profitability_demo.go

@@ -0,0 +1,214 @@
+// Package main demonstrates MEV bot profitability calculations
+package main
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/fraktal/mev-beta/pkg/math"
+)
+
+// Uncomment the main function below to run this demo
+// func main() {
+// 	runProfitabilityDemo()
+// }
+
+func runProfitabilityDemo() {
+	fmt.Println("=== MEV Bot Profitability Demonstration ===")
+	fmt.Println()
+
+	// Create a decimal converter for handling different denominations
+	dc := math.NewDecimalConverter()
+
+	// Example 1: Basic arbitrage calculation
+	fmt.Println("1. Basic Arbitrage Profitability:")
+
+	// Simulate a trade: 1 ETH -> USDC -> DAI -> ETH
+	inputETH, _ := dc.FromString("1.0", 18, "ETH")
+
+	// Exchange rates (simplified for demonstration)
+	// 1 ETH = 3000 USDC
+	usdcPerETH, _ := dc.FromString("3000.0", 6, "USDC")
+	usdcAmount, _ := dc.Multiply(inputETH, usdcPerETH, 6, "USDC")
+
+	// 1 USDC = 0.999 DAI (0.1% slippage)
+	daiPerUSDC, _ := dc.FromString("0.999", 18, "DAI")
+	daiAmount, _ := dc.Multiply(usdcAmount, daiPerUSDC, 18, "DAI")
+
+	// 1 DAI = 0.000333 ETH (slightly less than 1/3000 due to slippage)
+	ethPerDAI, _ := dc.FromString("0.000333", 18, "ETH")
+	outputETH, _ := dc.Multiply(daiAmount, ethPerDAI, 18, "ETH")
+
+	fmt.Printf("  Input:  %s ETH\n", formatDecimal(inputETH))
+	fmt.Printf("  Route:  ETH -> USDC -> DAI -> ETH\n")
+	fmt.Printf("  Output: %s ETH\n", formatDecimal(outputETH))
+
+	// Calculate gross profit
+	grossProfit, _ := dc.Subtract(outputETH, inputETH)
+	fmt.Printf("  Gross Profit: %s ETH\n", formatDecimal(grossProfit))
+
+	// Estimate gas costs (0.001 ETH for a 3-hop arbitrage)
+	gasCost, _ := dc.FromString("0.001", 18, "ETH")
+	netProfit, _ := dc.Subtract(grossProfit, gasCost)
+	fmt.Printf("  Gas Cost: %s ETH\n", formatDecimal(gasCost))
+	fmt.Printf("  Net Profit: %s ETH\n", formatDecimal(netProfit))
+
+	profitPercentage, _ := dc.CalculatePercentage(netProfit, inputETH)
+	fmt.Printf("  Profit Percentage: %s%%\n", formatDecimal(profitabilityToPercentage(profitPercentage)))
+
+	// Check if profitable (minimum 0.01 ETH profit)
+	minProfit, _ := dc.FromString("0.01", 18, "ETH")
+	isProfitable := netProfit.Value.Cmp(minProfit.Value) > 0
+	fmt.Printf("  Is Profitable (>0.01 ETH)? %t\n", isProfitable)
+	fmt.Println()
+
+	// Example 2: Price impact analysis
+	fmt.Println("2. Price Impact Analysis:")
+
+	// Simulate large trade affecting pool price
+	poolLiquidity, _ := dc.FromString("1000.0", 18, "ETH")
+	tradeSize, _ := dc.FromString("50.0", 18, "ETH")
+
+	// Price impact = (tradeSize / (tradeSize + liquidity))^2
+	// Simplified calculation for demonstration
+	priceImpact := calculateSimplePriceImpact(tradeSize, poolLiquidity)
+	fmt.Printf("  Pool Liquidity: %s ETH\n", formatDecimal(poolLiquidity))
+	fmt.Printf("  Trade Size: %s ETH\n", formatDecimal(tradeSize))
+	fmt.Printf("  Price Impact: %.2f%%\n", priceImpact*100)
+
+	// High price impact increases slippage and reduces profitability
+	fmt.Println("  Note: High price impact leads to increased slippage and reduced profitability")
+	fmt.Println()
+
+	// Example 3: Gas cost formatting demonstrations
+	fmt.Println("3. Gas Cost Formatting Examples:")
+	weiAmount := big.NewInt(1000000000000000000) // 1 ETH in wei
+	fmt.Printf("  Wei amount: %s\n", weiAmount.String())
+	fmt.Printf("  Formatted as ETH: %s\n", formatEtherFromWei(weiAmount))
+	fmt.Printf("  Formatted as Gwei: %s\n", formatGweiFromWei(weiAmount))
+	fmt.Printf("  Direct ether format: %s\n", formatEther(big.NewFloat(1.0)))
+	fmt.Println()
+
+	// Example 4: Risk assessment
+	fmt.Println("4. Key Profitability Factors:")
+
+	fmt.Println("  • Accurate price calculations and slippage modeling")
+	fmt.Println("  • Realistic gas cost estimation")
+	fmt.Println("  • Competition analysis for optimal bidding")
+	fmt.Println("  • Risk assessment to avoid unprofitable opportunities")
+	fmt.Println("  • Proper sizing to balance profits and price impact")
+	fmt.Println()
+}
+
+// Helper function to format decimals for display
+func formatDecimal(d *math.UniversalDecimal) string {
+	if d == nil {
+		return "0"
+	}
+
+	// Convert to float for easier formatting
+	f := new(big.Float).SetInt(d.Value)
+	f.Quo(f, big.NewFloat(float64(power(10, int(d.Decimals)))))
+
+	// Format based on symbol
+	switch d.Symbol {
+	case "PERCENT":
+		return fmt.Sprintf("%.2f", mustFloat64(f))
+	case "ETH":
+		return fmt.Sprintf("%.6f", mustFloat64(f))
+	case "USDC", "DAI":
+		return fmt.Sprintf("%.2f", mustFloat64(f))
+	default:
+		return fmt.Sprintf("%.4f", mustFloat64(f))
+	}
+}
+
+// Helper function to convert profitability percentage to readable format
+func profitabilityToPercentage(d *math.UniversalDecimal) *math.UniversalDecimal {
+	if d == nil {
+		return &math.UniversalDecimal{Value: big.NewInt(0), Decimals: 2, Symbol: "PERCENT"}
+	}
+
+	// Convert from decimal to percentage (multiply by 100)
+	f := new(big.Float).SetInt(d.Value)
+	f.Quo(f, big.NewFloat(float64(power(10, int(d.Decimals)))))
+	f.Mul(f, big.NewFloat(100))
+
+	// Convert back to big.Int with 2 decimal places
+	result := big.NewInt(0)
+	f.Mul(f, big.NewFloat(100)).Int(result)
+
+	return &math.UniversalDecimal{Value: result, Decimals: 2, Symbol: "PERCENT"}
+}
+
+// Simple price impact calculation
+func calculateSimplePriceImpact(tradeSize, liquidity *math.UniversalDecimal) float64 {
+	// Price impact = tradeSize / (tradeSize + liquidity)
+	// This is a simplified model
+
+	if liquidity.Value.Sign() == 0 {
+		return 0
+	}
+
+	ratio := new(big.Float).Quo(
+		new(big.Float).SetInt(tradeSize.Value),
+		new(big.Float).SetInt(liquidity.Value),
+	)
+
+	// Square the ratio for concentrated liquidity impact
+	result := new(big.Float).Mul(ratio, ratio)
+
+	f, _ := result.Float64()
+	return f
+}
+
+// Helper function for integer powers
+func power(base, exp int) int {
+	result := 1
+	for i := 0; i < exp; i++ {
+		result *= base
+	}
+	return result
+}
+
+// Helper function to convert big.Float to float64
+func mustFloat64(f *big.Float) float64 {
+	if f == nil {
+		return 0
+	}
+	result, _ := f.Float64()
+	return result
+}
+
+// formatEther formats a big.Float as ETH
+func formatEther(amount *big.Float) string {
+	if amount == nil {
+		return "0 ETH"
+	}
+	f, _ := amount.Float64()
+	return fmt.Sprintf("%.6f ETH", f)
+}
+
+// formatEtherFromWei formats wei amount as ETH
+func formatEtherFromWei(wei *big.Int) string {
+	if wei == nil {
+		return "0 ETH"
+	}
+	// Convert wei to ETH (divide by 10^18)
+	eth := new(big.Float).SetInt(wei)
+	eth.Quo(eth, big.NewFloat(1e18))
+	f, _ := eth.Float64()
+	return fmt.Sprintf("%.6f ETH", f)
+}
+
+// formatGweiFromWei formats wei amount as Gwei
+func formatGweiFromWei(wei *big.Int) string {
+	if wei == nil {
+		return "0 Gwei"
+	}
+	// Convert wei to Gwei (divide by 10^9)
+	gwei := new(big.Float).SetInt(wei)
+	gwei.Quo(gwei, big.NewFloat(1e9))
+	f, _ := gwei.Float64()
+	return fmt.Sprintf("%.2f Gwei", f)
+}