Add core simulation (Agent, Pool, Simulation)

core/__init__.py

@@ -3,6 +3,5 @@
 from .agent import Agent
 from .defi_mechanics import Pool
 from .simulation import Simulation
-from .analyzer import Analyzer
 
-__all__ = ["Agent", "Pool", "Simulation", "Analyzer"]
+__all__ = ["Agent", "Pool", "Simulation"]

core/agent.py

@@ -0,0 +1,224 @@
+"""Agent class for DeFi simulation."""
+
+import json
+from typing import Dict, List, Tuple, Optional
+from dataclasses import dataclass, field
+
+from api.minimax_client import MiniMaxClient
+from config import INITIAL_TOKENS
+
+
+@dataclass
+class Agent:
+    """DeFi trading agent powered by MiniMax."""
+
+    name: str
+    token_a: float = INITIAL_TOKENS
+    token_b: float = INITIAL_TOKENS
+    trade_history: List[Dict] = field(default_factory=list)
+    learning_summary: str = ""
+    alliances: Dict[str, str] = field(default_factory=dict)
+
+    def __post_init__(self):
+        self.client = MiniMaxClient()
+
+    def get_state(self) -> Dict:
+        """Get current state for decision making."""
+        return {
+            "name": self.name,
+            "token_a": round(self.token_a, 2),
+            "token_b": round(self.token_b, 2),
+            "profit": round(self.calculate_profit(), 2),
+            "alliances": self.alliances
+        }
+
+    def decide(self, observation: Dict, pool_state: Dict, other_agents: List["Agent"], turn: int) -> Tuple[Dict, str]:
+        """
+        Ask MiniMax for a decision based on current state.
+
+        Returns:
+            Tuple of (decision_dict, thinking_text)
+        """
+        prompt = self._build_prompt(observation, pool_state, other_agents, turn)
+
+        system_prompt = """You are a strategic DeFi trader in an automated market simulation.
+Analyze the market state and make optimal trading decisions.
+Output ONLY valid JSON with your reasoning."""
+
+        decision, thinking = self.client.call(prompt, system_prompt)
+
+        # Log the decision
+        self.trade_history.append({
+            "turn": turn,
+            "action": decision.get("action", decision.get("action_type", "unknown")),
+            "reasoning": decision.get("reasoning", ""),
+            "thinking": thinking
+        })
+
+        return decision, thinking
+
+    def _build_prompt(self, observation: Dict, pool_state: Dict, other_agents: List["Agent"], turn: int) -> str:
+        """Build the decision prompt."""
+        other_states = [a.get_state() for a in other_agents if a.name != self.name]
+
+        prompt = f"""
+You are {self.name}, an AI agent in a DeFi market simulation.
+
+=== YOUR STATE ===
+Token A: {self.token_a:.2f}
+Token B: {self.token_b:.2f}
+Profit: {self.calculate_profit():.2f}
+
+=== MARKET STATE ===
+Pool reserves: A={pool_state.get('reserve_a', 0):.2f}, B={pool_state.get('reserve_b', 0):.2f}
+Price (A/B): {pool_state.get('price_ab', 0):.4f}
+
+=== OTHER AGENTS ===
+{json.dumps(other_states, indent=2)}
+
+=== YOUR LEARNING ===
+{self.learning_summary if self.learning_summary else "No previous runs yet."}
+
+=== AVAILABLE ACTIONS ===
+1. "swap": Trade tokens (specify from, to, amount)
+2. "provide_liquidity": Add liquidity to pool (specify amounts)
+3. "propose_alliance": Suggest collaboration (specify agent name)
+4. "do_nothing": Wait for better opportunity
+
+Output JSON:
+{{
+    "action": "swap|provide_liquidity|propose_alliance|do_nothing",
+    "reasoning": "your reasoning",
+    "payload": {{...action specific data...}}
+}}
+"""
+        return prompt
+
+    def calculate_profit(self) -> float:
+        """Calculate profit from initial state."""
+        return (self.token_a + self.token_b) - (INITIAL_TOKENS * 2)
+
+    def infer_strategy(self) -> str:
+        """Infer the agent's strategy from recent actions."""
+        if not self.trade_history:
+            return "unknown"
+
+        recent = self.trade_history[-10:]
+        actions = [h["action"] for h in recent if "action" in h]
+
+        if not actions:
+            return "unknown"
+
+        # Return most common action
+        from collections import Counter
+        return Counter(actions).most_common(1)[0][0]
+
+    def update_learning(self, run_number: int, metrics: Dict):
+        """Extract learnings after a run completes."""
+        prompt = f"""
+You just completed run {run_number}.
+
+Your performance: Profit={self.calculate_profit():.2f}, Strategy={self.infer_strategy()}
+Market metrics: Gini={metrics.get('gini_coefficient', 0):.3f}, Avg Profit={metrics.get('avg_agent_profit', 0):.2f}
+
+What did you learn in 1-2 sentences?
+Output JSON: {{"learning": "your learning"}}
+"""
+
+        try:
+            response, _ = self.client.call(prompt)
+            self.learning_summary = response.get("learning", "")
+        except Exception:
+            self.learning_summary = "Learning extraction failed."
+
+    def execute_action(self, decision: Dict, pool: "Pool") -> bool:
+        """Execute the decided action on the pool."""
+        action = decision.get("action", decision.get("action_type", ""))
+        payload = decision.get("payload", {})
+
+        if action == "swap":
+            return self._execute_swap(payload, pool)
+        elif action == "provide_liquidity":
+            return self._execute_liquidity(payload, pool)
+        elif action == "propose_alliance":
+            return self._execute_alliance(payload)
+        else:
+            # do_nothing or unknown action - always succeeds
+            return True
+
+    def _execute_swap(self, payload: Dict, pool: "Pool") -> bool:
+        """Execute a swap action."""
+        amount = payload.get("amount", 0)
+        from_token = payload.get("from", "a")
+
+        if from_token == "a" and self.token_a >= amount:
+            output, fee = pool.swap("a", amount, self.name)
+            self.token_a -= amount
+            self.token_b += output
+            return True
+        elif from_token == "b" and self.token_b >= amount:
+            output, fee = pool.swap("b", amount, self.name)
+            self.token_b -= amount
+            self.token_a += output
+            return True
+
+        return False
+
+    def _execute_liquidity(self, payload: Dict, pool: "Pool") -> bool:
+        """Execute a provide liquidity action."""
+        amount_a = payload.get("amount_a", 0)
+        amount_b = payload.get("amount_b", 0)
+
+        if self.token_a >= amount_a and self.token_b >= amount_b:
+            pool.provide_liquidity(amount_a, amount_b, self.name)
+            self.token_a -= amount_a
+            self.token_b -= amount_b
+            return True
+
+        return False
+
+    def _execute_alliance(self, payload: Dict) -> bool:
+        """Record an alliance proposal."""
+        agent_name = payload.get("agent_name", "")
+        if agent_name:
+            self.alliances[agent_name] = "proposed"
+            return True
+        return False
+
+
+def test_agent():
+    """Test the Agent class."""
+    from core.defi_mechanics import Pool
+
+    print("Testing Agent class...")
+
+    # Create agent
+    agent = Agent("TestAgent")
+    print(f"Created agent: {agent.name}")
+    print(f"Initial state: {agent.get_state()}")
+
+    # Create pool
+    pool = Pool(reserve_a=1000, reserve_b=1000)
+
+    # Get decision
+    observation = {"turn": 0, "event": "test"}
+    pool_state = pool.__dict__
+
+    print("\nGetting decision from MiniMax...")
+    decision, thinking = agent.decide(observation, pool_state, [], 0)
+
+    print(f"Decision: {json.dumps(decision, indent=2)}")
+    print(f"Thinking length: {len(thinking)}")
+    print(f"Profit: {agent.calculate_profit():.2f}")
+    print(f"Strategy: {agent.infer_strategy()}")
+
+    # Test action execution
+    if decision.get("action") == "swap":
+        agent.execute_action(decision, pool)
+        print(f"After swap: {agent.get_state()}")
+
+    print("\nAgent test complete!")
+
+
+if __name__ == "__main__":
+    test_agent()

core/defi_mechanics.py

@@ -0,0 +1,167 @@
+"""DeFi mechanics: Constant product AMM pool."""
+
+from typing import Dict, Tuple
+from dataclasses import dataclass, field
+
+from config import SWAP_FEE
+
+
+@dataclass
+class Pool:
+    """Constant product automated market maker (AMM)."""
+
+    reserve_a: float = 1000
+    reserve_b: float = 1000
+    liquidity_providers: Dict[str, float] = field(default_factory=dict)
+    _constant_product: float = None
+
+    def __post_init__(self):
+        self._constant_product = self.reserve_a * self.reserve_b
+
+    def swap(self, token_in: str, amount_in: float, agent_name: str) -> Tuple[float, float]:
+        """
+        Execute a swap on the pool.
+
+        Returns:
+            Tuple of (amount_out, fee)
+        """
+        if amount_in <= 0:
+            return 0, 0
+
+        if token_in == "a":
+            amount_out = self._calculate_output(amount_in, self.reserve_a, self.reserve_b)
+            fee = amount_out * SWAP_FEE
+            amount_out -= fee
+
+            self.reserve_a += amount_in
+            self.reserve_b -= amount_out
+        else:
+            amount_out = self._calculate_output(amount_in, self.reserve_b, self.reserve_a)
+            fee = amount_out * SWAP_FEE
+            amount_out -= fee
+
+            self.reserve_b += amount_in
+            self.reserve_a -= amount_out
+
+        self._constant_product = self.reserve_a * self.reserve_b
+        return amount_out, fee
+
+    def provide_liquidity(self, amount_a: float, amount_b: float, agent_name: str) -> float:
+        """Add liquidity to the pool and mint LP tokens."""
+        if amount_a <= 0 or amount_b <= 0:
+            return 0
+
+        # Calculate LP tokens to mint (simple share model)
+        total_liquidity = sum(self.liquidity_providers.values())
+        if total_liquidity == 0:
+            # Initial liquidity - use geometric mean
+            lp_tokens = (amount_a * amount_b) ** 0.5
+        else:
+            # Proportional to existing liquidity
+            share_a = amount_a / self.reserve_a
+            share_b = amount_b / self.reserve_b
+            share = min(share_a, share_b)  # Use smaller share to prevent imbalance
+            lp_tokens = share * (self.reserve_a + self.reserve_b)
+
+        self.reserve_a += amount_a
+        self.reserve_b += amount_b
+        self.liquidity_providers[agent_name] = (
+            self.liquidity_providers.get(agent_name, 0) + lp_tokens
+        )
+
+        self._constant_product = self.reserve_a * self.reserve_b
+        return lp_tokens
+
+    def withdraw_liquidity(self, lp_tokens: float, agent_name: str) -> Tuple[float, float]:
+        """Remove liquidity and burn LP tokens."""
+        total_lp = sum(self.liquidity_providers.values())
+        if total_lp == 0 or lp_tokens <= 0:
+            return 0, 0
+
+        share = lp_tokens / total_lp
+        amount_a = self.reserve_a * share
+        amount_b = self.reserve_b * share
+
+        self.reserve_a -= amount_a
+        self.reserve_b -= amount_b
+        self.liquidity_providers[agent_name] -= lp_tokens
+
+        self._constant_product = self.reserve_a * self.reserve_b
+        return amount_a, amount_b
+
+    @property
+    def price_ab(self) -> float:
+        """Get price of A in terms of B."""
+        return self.reserve_b / self.reserve_a if self.reserve_a > 0 else 0
+
+    @property
+    def price_ba(self) -> float:
+        """Get price of B in terms of A."""
+        return self.reserve_a / self.reserve_b if self.reserve_b > 0 else 0
+
+    @property
+    def total_liquidity(self) -> float:
+        """Get total liquidity in the pool."""
+        return sum(self.liquidity_providers.values())
+
+    @property
+    def constant_product(self) -> float:
+        """Get the constant product k = a * b."""
+        if self._constant_product is None:
+            self._constant_product = self.reserve_a * self.reserve_b
+        return self._constant_product
+
+    @staticmethod
+    def _calculate_output(amount_in: float, reserve_in: float, reserve_out: float) -> float:
+        """
+        Calculate output amount using constant product formula.
+        (x + dx) * (y - dy) = x * y
+        dy = y * dx / (x + dx)
+        """
+        if amount_in <= 0 or reserve_in <= 0 or reserve_out <= 0:
+            return 0
+
+        numerator = amount_in * reserve_out
+        denominator = reserve_in + amount_in
+
+        return numerator / denominator
+
+    def get_state(self) -> Dict:
+        """Get pool state for agents."""
+        return {
+            "reserve_a": self.reserve_a,
+            "reserve_b": self.reserve_b,
+            "price_ab": self.price_ab,
+            "price_ba": self.price_ba,
+            "total_liquidity": self.total_liquidity,
+            "constant_product": self.constant_product
+        }
+
+
+def test_pool():
+    """Test the Pool class."""
+    print("Testing Pool class...")
+
+    # Create pool
+    pool = Pool(reserve_a=1000, reserve_b=1000)
+    print(f"Initial pool: A={pool.reserve_a}, B={pool.reserve_b}")
+    print(f"Price A/B: {pool.price_ab:.4f}")
+    print(f"Constant product: {pool.constant_product}")
+
+    # Test swap
+    print("\nTesting swap: 100 A for B...")
+    amount_out, fee = pool.swap("a", 100, "TestAgent")
+    print(f"Output: {amount_out:.4f} B, Fee: {fee:.4f}")
+    print(f"Pool after swap: A={pool.reserve_a:.2f}, B={pool.reserve_b:.2f}")
+
+    # Test liquidity provision
+    print("\nTesting liquidity provision...")
+    lp = pool.provide_liquidity(200, 200, "TestAgent")
+    print(f"LP tokens minted: {lp:.4f}")
+    print(f"Total liquidity: {pool.total_liquidity:.4f}")
+
+    print("\nPool test complete!")
+
+
+if __name__ == "__main__":
+    test_pool()

core/simulation.py

@@ -0,0 +1,225 @@
+"""Main simulation engine for DeFi agent market."""
+
+import json
+from typing import List, Dict, Optional
+from dataclasses import dataclass
+
+from core.agent import Agent
+from core.defi_mechanics import Pool
+from api.supabase_client import (
+    SupabaseClient, RunData, AgentStateData, PoolStateData, ActionData, MetricsData
+)
+from config import NUM_AGENTS, TURNS_PER_RUN
+
+
+@dataclass
+class Simulation:
+    """Orchestrates the DeFi agent simulation."""
+
+    num_agents: int = NUM_AGENTS
+    turns_per_run: int = TURNS_PER_RUN
+    supabase: Optional[SupabaseClient] = None
+
+    def __post_init__(self):
+        self.agents: List[Agent] = []
+        self.pool: Optional[Pool] = None
+        self.current_run_id: Optional[int] = None
+        self.current_run_number: int = 0
+
+        if self.supabase is None:
+            try:
+                self.supabase = SupabaseClient()
+            except ValueError:
+                print("Warning: Supabase not configured. Running without persistence.")
+                self.supabase = None
+
+    def initialize_run(self, run_number: int = None):
+        """Initialize a new run with agents and pool."""
+        if run_number is None:
+            if self.supabase:
+                run_number = self.supabase.get_next_run_number()
+            else:
+                run_number = self.current_run_number + 1
+
+        self.current_run_number = run_number
+        self.agents = [Agent(f"Agent_{i}") for i in range(self.num_agents)]
+        self.pool = Pool()
+
+        print(f"Initialized run {run_number} with {self.num_agents} agents")
+
+        if self.supabase:
+            self.current_run_id = self.supabase.create_run(run_number)
+            print(f"Created run in database: ID {self.current_run_id}")
+
+    def run(self, run_number: int = None) -> Dict:
+        """Execute a complete simulation run."""
+        self.initialize_run(run_number)
+
+        print(f"\nStarting run {self.current_run_number} with {self.turns_per_run} turns...")
+
+        for turn in range(self.turns_per_run):
+            print(f"\n--- Turn {turn + 1}/{self.turns_per_run} ---")
+
+            # Each agent makes a decision
+            for agent in self.agents:
+                decision, thinking = self._agent_decide(agent, turn)
+
+                # Execute action
+                if decision:
+                    success = agent.execute_action(decision, self.pool)
+                    print(f"  {agent.name}: {decision.get('action', 'unknown')} {'OK' if success else 'FAIL'}")
+
+                # Save action to database
+                if self.supabase:
+                    self._save_action(agent, turn, decision, thinking)
+
+            # Save state snapshots
+            if self.supabase:
+                self._save_states(turn)
+
+        # Calculate and save metrics
+        metrics = self._calculate_metrics()
+
+        if self.supabase:
+            self.supabase.complete_run(self.current_run_id)
+            self.supabase.save_metrics(
+                MetricsData(
+                    run_id=self.current_run_id,
+                    gini_coefficient=metrics.get("gini_coefficient", 0),
+                    cooperation_rate=metrics.get("cooperation_rate", 0),
+                    betrayal_count=metrics.get("betrayal_count", 0),
+                    avg_agent_profit=metrics.get("avg_agent_profit", 0),
+                    pool_stability=metrics.get("pool_stability", 0)
+                )
+            )
+
+        # Update agent learning
+        for agent in self.agents:
+            agent.update_learning(self.current_run_number, metrics)
+
+        print(f"\n--- Run {self.current_run_number} Complete ---")
+        print(f"Final metrics: {json.dumps(metrics, indent=2)}")
+
+        self.current_run_number += 1
+        return metrics
+
+    def _agent_decide(self, agent: Agent, turn: int) -> tuple:
+        """Get decision from agent."""
+        observation = {
+            "turn": turn,
+            "event": "trading"
+        }
+        pool_state = self.pool.get_state()
+
+        try:
+            decision, thinking = agent.decide(
+                observation,
+                pool_state,
+                self.agents,
+                turn
+            )
+            return decision, thinking
+        except Exception as e:
+            print(f"  {agent.name}: Decision error - {e}")
+            return {"action": "do_nothing", "reasoning": f"Error: {e}"}, ""
+
+    def _save_action(self, agent: Agent, turn: int, decision: Dict, thinking: str):
+        """Save agent action to database."""
+        self.supabase.save_action(ActionData(
+            run_id=self.current_run_id,
+            turn=turn,
+            agent_name=agent.name,
+            action_type=decision.get("action", "unknown"),
+            payload=decision.get("payload", {}),
+            reasoning_trace=decision.get("reasoning", ""),
+            thinking_trace=thinking
+        ))
+
+    def _save_states(self, turn: int):
+        """Save agent and pool states to database."""
+        # Save agent states
+        for agent in self.agents:
+            self.supabase.save_agent_state(AgentStateData(
+                run_id=self.current_run_id,
+                turn=turn,
+                agent_name=agent.name,
+                token_a_balance=agent.token_a,
+                token_b_balance=agent.token_b,
+                profit=agent.calculate_profit(),
+                strategy=agent.infer_strategy()
+            ))
+
+        # Save pool state
+        self.supabase.save_pool_state(PoolStateData(
+            run_id=self.current_run_id,
+            turn=turn,
+            reserve_a=self.pool.reserve_a,
+            reserve_b=self.pool.reserve_b,
+            price_ab=self.pool.price_ab,
+            total_liquidity=self.pool.total_liquidity
+        ))
+
+    def _calculate_metrics(self) -> Dict:
+        """Calculate run metrics."""
+        if not self.agents:
+            return {}
+
+        profits = [a.calculate_profit() for a in self.agents]
+        gini = self._gini_coefficient(profits)
+
+        return {
+            "gini_coefficient": gini,
+            "avg_agent_profit": sum(profits) / len(profits),
+            "cooperation_rate": self._calculate_cooperation(),
+            "betrayal_count": self._count_betrayals(),
+            "pool_stability": self.pool.reserve_a * self.pool.reserve_b
+        }
+
+    @staticmethod
+    def _gini_coefficient(values: List[float]) -> float:
+        """Calculate Gini coefficient for wealth distribution."""
+        if not values or sum(values) == 0:
+            return 0
+
+        sorted_vals = sorted(values)
+        n = len(sorted_vals)
+        cumsum = 0
+        for i, val in enumerate(sorted_vals):
+            cumsum += (i + 1) * val
+
+        gini = (2 * cumsum) / (n * sum(sorted_vals)) - (n + 1) / n
+        return max(0, gini)  # Ensure non-negative
+
+    def _calculate_cooperation(self) -> float:
+        """Calculate cooperation rate (alliances / agents)."""
+        total_alliances = sum(len(a.alliances) for a in self.agents)
+        return total_alliances / max(len(self.agents), 1)
+
+    def _count_betrayals(self) -> int:
+        """Count betrayal events (placeholder for future implementation)."""
+        return 0
+
+
+def test_simulation():
+    """Test the simulation with a short run."""
+    print("Testing Simulation class...")
+    print("(Running without Supabase for quick test)\n")
+
+    sim = Simulation(num_agents=3, turns_per_run=3, supabase=None)
+    metrics = sim.run()
+
+    print(f"\nFinal Metrics:")
+    print(f"  Gini Coefficient: {metrics['gini_coefficient']:.4f}")
+    print(f"  Avg Agent Profit: {metrics['avg_agent_profit']:.2f}")
+    print(f"  Pool Stability: {metrics['pool_stability']:.2f}")
+
+    # Show agent states
+    print("\nFinal Agent States:")
+    for agent in sim.agents:
+        print(f"  {agent.name}: A={agent.token_a:.2f}, B={agent.token_b:.2f}, Profit={agent.calculate_profit():.2f}")
+
+    print("\nSimulation test complete!")
+
+
+if __name__ == "__main__":
+    test_simulation()