Cryptocurrency Trading Basics — Order Types, Exchanges, and Strategy

# Order book simulation and trading execution
import random
from typing import List, Dict
from collections import deque

class Order:
    def __init__(self, order_id: str, side: str, price: float,
                 quantity: float, order_type: str = "limit"):
        self.order_id = order_id
        self.side = side      # "buy" or "sell"
        self.price = price
        self.quantity = quantity
        self.remaining = quantity
        self.order_type = order_type  # "limit", "market", "stop"

    def __repr__(self):
        return f"{self.side.upper()} {self.remaining} @ ${self.price}"

class OrderBook:
    def __init__(self):
        self.bids: List[Dict] = []  # buy orders (sorted descending)
        self.asks: List[Dict] = []  # sell orders (sorted ascending)
        self.trades: List[Dict] = []

    def add_order(self, order: Order):
        """Add an order to the book and attempt to match."""
        if order.order_type == "market":
            self._execute_market(order)
        elif order.order_type == "limit":
            self._add_limit_order(order)
        elif order.order_type == "stop":
            # Stop orders become market orders when triggered
            self._add_stop_order(order)

    def _add_limit_order(self, order: Order):
        """Add a limit order to the book."""
        # Try to match against existing orders first
        matched = False

        if order.side == "buy":
            # Check if any ask is at or below our bid
            for ask in sorted(self.asks, key=lambda x: x["price"]):
                if ask["price"] <= order.price and order.remaining > 0:
                    matched_trade = self._match_orders(order, ask)
                    if matched_trade:
                        self.trades.append(matched_trade)
                if order.remaining <= 0:
                    return

        else:  # sell
            for bid in sorted(self.bids, key=lambda x: x["price"], reverse=True):
                if bid["price"] >= order.price and order.remaining > 0:
                    matched_trade = self._match_orders(order, bid)
                    if matched_trade:
                        self.trades.append(matched_trade)
                if order.remaining <= 0:
                    return

        # If not fully matched, add remaining to book
        if order.remaining > 0:
            entry = {
                "order_id": order.order_id,
                "price": order.price,
                "quantity": order.remaining,
                "remaining": order.remaining
            }
            if order.side == "buy":
                self.bids.append(entry)
                self.bids.sort(key=lambda x: x["price"], reverse=True)
            else:
                self.asks.append(entry)
                self.asks.sort(key=lambda x: x["price"])

    def _execute_market(self, order: Order):
        """Execute a market order immediately."""
        total_cost = 0
        filled_quantity = 0

        if order.side == "buy":
            # Take from asks (lowest price first)
            for ask in sorted(self.asks, key=lambda x: x["price"]):
                if order.remaining <= 0:
                    break
                trade_qty = min(order.remaining, ask["remaining"])
                total_cost += trade_qty * ask["price"]
                filled_quantity += trade_qty
                order.remaining -= trade_qty
                ask["remaining"] -= trade_qty

        else:  # sell
            for bid in sorted(self.bids, key=lambda x: x["price"], reverse=True):
                if order.remaining <= 0:
                    break
                trade_qty = min(order.remaining, bid["remaining"])
                total_cost += trade_qty * bid["price"]
                filled_quantity += trade_qty
                order.remaining -= trade_qty
                bid["remaining"] -= trade_qty

        # Clean up filled orders
        self.bids = [b for b in self.bids if b["remaining"] > 0]
        self.asks = [a for a in self.asks if a["remaining"] > 0]

        avg_price = total_cost / filled_quantity if filled_quantity else 0
        self.trades.append({
            "side": order.side,
            "type": "market",
            "quantity": round(filled_quantity, 4),
            "avg_price": round(avg_price, 2),
            "total_cost": round(total_cost, 2)
        })

    def _match_orders(self, taker: Order, maker: dict) -> dict:
        """Match a taker order against a maker order."""
        trade_qty = min(taker.remaining, maker["remaining"])
        price = maker["price"]

        taker.remaining -= trade_qty
        maker["remaining"] -= trade_qty

        return {
            "side": taker.side,
            "type": "limit",
            "price": price,
            "quantity": round(trade_qty, 4),
            "total": round(trade_qty * price, 2)
        }

    def get_spread(self) -> float:
        """Calculate the bid-ask spread."""
        if not self.bids or not self.asks:
            return 0
        best_bid = self.bids[0]["price"]
        best_ask = self.asks[0]["price"]
        return best_ask - best_bid

    def __repr__(self):
        spread = self.get_spread()
        lines = [f"Order Book (Spread: ${spread:.2f})", "─" * 40]

        # Show top 5 asks (reversed so lowest ask is closest to spread)
        lines.append("ASKS:")
        for ask in reversed(self.asks[-5:]):
            lines.append(f"  {ask['remaining']} @ ${ask['price']}")

        lines.append(f"{'─' * 40}")

        # Show top 5 bids
        lines.append("BIDS:")
        for bid in self.bids[:5]:
            lines.append(f"  {bid['remaining']} @ ${bid['price']}")

        return "\n".join(lines)

# Simulate a trading session
book = OrderBook()

# Initial liquidity
book.add_order(Order("b1", "buy", 1950, 2))
book.add_order(Order("b2", "buy", 1940, 5))
book.add_order(Order("b3", "buy", 1930, 3))
book.add_order(Order("a1", "sell", 2050, 4))
book.add_order(Order("a2", "sell", 2060, 6))
book.add_order(Order("a3", "sell", 2070, 2))

print(book)
print()

# Trader places a market buy for 3 ETH
market_buy = Order("t1", "buy", 0, 3, "market")
book.add_order(market_buy)
print("Market Buy 3 ETH executed:")
print(f"  Remaining after fill: {market_buy.remaining}")
print()

print(book)
print()

# Trader places a limit sell at 2100
limit_sell = Order("t2", "sell", 2100, 1.5, "limit")
book.add_order(limit_sell)
print("Limit Sell 1.5 ETH @ $2100 added to book")

print(f"\nLast 3 trades:")
for t in book.trades[-3:]:
    print(f"  {t}")

# Position sizing and risk management
def calculate_position_size(
    account_balance: float,
    risk_per_trade_pct: float,
    entry_price: float,
    stop_loss_price: float,
    direction: str = "long"
) -> dict:
    """
    Calculate position size based on fixed percentage risk model.
    
    Args:
        account_balance: Total account value
        risk_per_trade_pct: Maximum risk per trade (e.g., 2 = 2%)
        entry_price: Planned entry price
        stop_loss_price: Stop loss price
        direction: "long" or "short"
    
    Returns:
        Dictionary with position details
    """
    max_risk_amount = account_balance * (risk_per_trade_pct / 100)

    if direction == "long":
        risk_per_unit = entry_price - stop_loss_price
    else:  # short
        risk_per_unit = stop_loss_price - entry_price

    if risk_per_unit <= 0:
        return {"error": "Stop loss must be below entry for longs, above for shorts"}

    position_size = max_risk_amount / risk_per_unit
    position_value = position_size * entry_price
    leverage_needed = position_value / account_balance if account_balance else 0

    return {
        "account_balance": account_balance,
        "max_risk_amount": round(max_risk_amount, 2),
        "risk_pct": risk_per_trade_pct,
        "entry_price": entry_price,
        "stop_loss": stop_loss_price,
        "position_size_units": round(position_size, 4),
        "position_value_usd": round(position_value, 2),
        "leverage_required": round(leverage_needed, 2),
        "risk_reward_if_1r_target": f"Target: ${round(entry_price + risk_per_unit, 2)} (1:1 R:R)"
    }

# Example: Trading ETH with $10,000 account
position = calculate_position_size(
    account_balance=10000,
    risk_per_trade_pct=2,  # max $200 risk per trade
    entry_price=2000,
    stop_loss_price=1950,  # 2.5% below entry
)

print("Position Sizing (2% Risk Model):")
for key, value in position.items():
    print(f"  {key}: {value}")

print()

# Scenario: what if price hits stop-loss?
loss = 40 * abs(2000 - 1950)  # 40 ETH * $50
print(f"Max loss at stop: ${loss} (${loss/10000*100:.1f}% of account)")