Cryptocurrency Tax Guide — Reporting, Tracking, and Compliance

# Cryptocurrency capital gains calculator
from datetime import datetime
from typing import List, Dict

class CryptoTransaction:
    def __init__(self, date: str, asset: str, tx_type: str,
                 amount: float, price_usd: float, fee_usd: float = 0):
        self.date = datetime.strptime(date, "%Y-%m-%d")
        self.asset = asset
        self.tx_type = tx_type  # "buy", "sell", "swap", "income"
        self.amount = amount
        self.price_usd = price_usd
        self.fee_usd = fee_usd
        self.total_usd = amount * price_usd

    def __repr__(self):
        return f"{self.date.date()}: {self.tx_type} {self.amount} {self.asset} @ ${self.price_usd}"

class TaxCalculator:
    def __init__(self, method: str = "fifo"):
        """method: 'fifo', 'lifo', 'specific_id'"""
        self.method = method
        self.transactions: List[CryptoTransaction] = []
        self.holdings: List[Dict] = []  # tax lots

    def add_transaction(self, tx: CryptoTransaction):
        self.transactions.append(tx)

    def calculate_gains(self, year: int) -> dict:
        """Calculate capital gains for a given tax year using selected method."""
        total_gains = 0.0
        total_losses = 0.0
        trades = []

        for tx in self.transactions:
            if tx.date.year != year:
                continue

            if tx.tx_type == "buy":
                # Add to holdings
                self.holdings.append({
                    "date": tx.date,
                    "asset": tx.asset,
                    "amount": tx.amount,
                    "cost_basis": tx.total_usd,
                    "price_per_unit": tx.price_usd
                })

            elif tx.tx_type == "sell":
                remaining = tx.amount
                total_cost = 0.0
                lots_used = []

                while remaining > 0 and self.holdings:
                    if self.method == "fifo":
                        lot = self.holdings[0]
                    elif self.method == "lifo":
                        lot = self.holdings[-1]

                    used = min(remaining, lot["amount"])
                    lot_cost = used * lot["price_per_unit"]
                    total_cost += lot_cost

                    lot["amount"] -= used
                    remaining -= used

                    lots_used.append({
                        "lot_date": lot["date"],
                        "amount": used,
                        "cost": lot_cost
                    })

                    if lot["amount"] <= 0:
                        self.holdings.remove(lot)

                proceeds = tx.total_usd - tx.fee_usd
                gain = proceeds - total_cost

                if gain > 0:
                    total_gains += gain
                else:
                    total_losses += abs(gain)

                trades.append({
                    "date": tx.date,
                    "asset": tx.asset,
                    "amount": tx.amount,
                    "proceeds": round(proceeds, 2),
                    "cost_basis": round(total_cost, 2),
                    "gain_loss": round(gain, 2),
                    "lots": lots_used
                })

        net_gain = total_gains - total_losses
        return {
            "year": year,
            "method": self.method,
            "total_gains": round(total_gains, 2),
            "total_losses": round(total_losses, 2),
            "net_gain_loss": round(net_gain, 2),
            "trades": trades,
            "trades_count": len(trades)
        }

# Example transaction history
tax_calc = TaxCalculator(method="fifo")
tax_calc.add_transaction(CryptoTransaction("2024-01-15", "ETH", "buy", 5, 2500))
tax_calc.add_transaction(CryptoTransaction("2024-02-20", "ETH", "buy", 3, 2800))
tax_calc.add_transaction(CryptoTransaction("2024-06-10", "ETH", "sell", 4, 3200, 50))
tax_calc.add_transaction(CryptoTransaction("2024-09-05", "BTC", "buy", 0.5, 60000))
tax_calc.add_transaction(CryptoTransaction("2024-11-20", "BTC", "sell", 0.3, 75000, 30))

result = tax_calc.calculate_gains(2024)
print(f"Tax Year {result['year']} ({result['method'].upper()}):")
print(f"  Total gains: ${result['total_gains']}")
print(f"  Total losses: ${result['total_losses']}")
print(f"  Net gain/loss: ${result['net_gain_loss']}")
print(f"  Number of trades: {result['trades_count']}")
print("\nTrade breakdown:")
for t in result['trades']:
    print(f"  {t['date'].date()}: {t['amount']} {t['asset']} "
          f"→ gain/loss ${t['gain_loss']}")

# DeFi transaction tax analyzer
def analyze_defi_tax_events(activities: list) -> list:
    """Analyze DeFi activities and identify taxable events."""
    events = []

    for activity in activities:
        tx_type = activity.get("type")
        events_list = []

        if tx_type == "liquidity_provide":
            # Providing liquidity = swapping tokens (taxable swap)
            events_list.append({
                "event": "Swap: Token A → LP tokens",
                "taxable": True,
                "gain_type": "capital_gains",
                "notes": "Swapping assets to LP tokens is a disposal"
            })
            events_list.append({
                "event": "Receive LP tokens",
                "taxable": False,
                "gain_type": "none",
                "notes": "LP tokens have zero cost basis (arguably)"
            })

        elif tx_type == "yield_farm":
            events_list.append({
                "event": "Stake LP tokens in farm",
                "taxable": False,
                "gain_type": "none",
                "notes": "Moving tokens to a staking contract is not a disposal"
            })
            events_list.append({
                "event": "Receive reward tokens",
                "taxable": True,
                "gain_type": "income",
                "notes": "Rewards are ordinary income at fair market value when received"
            })

        elif tx_type == "lending_supply":
            events_list.append({
                "event": "Supply tokens to lending pool",
                "taxable": False,
                "gain_type": "none",
                "notes": "Depositing is not a disposal if you retain ownership"
            })
            events_list.append({
                "event": "Receive interest in same token",
                "taxable": True,
                "gain_type": "income",
                "notes": "Interest is ordinary income"
            })

        events.extend(events_list)

    return events

defi_activities = [
    {"type": "liquidity_provide", "tokens": ["ETH", "USDC"]},
    {"type": "yield_farm", "protocol": "Uniswap"},
    {"type": "lending_supply", "protocol": "Aave"},
]

print("DeFi Tax Event Analysis:")
for event in analyze_defi_tax_events(defi_activities):
    status = "TAXABLE" if event["taxable"] else "NOT TAXABLE"
    print(f"  [{status}] {event['event']}")
    print(f"    Type: {event['gain_type']}")
    print(f"    Note: {event['notes']}")
    print()