from __future__ import annotations from typing import Any import gymnasium as gym from gymnasium import spaces import numpy as np from .actions import decode_continuous_action, decode_discrete_action, discrete_action_grid from .config import BenchmarkConfig, load_config from .data import BenchmarkData, load_benchmark_data class SolarChainBenchmarkEnv(gym.Env): """Gymnasium environment for physics-constrained SolarChain market governance.""" metadata = {"render_modes": []} def __init__(self, config: BenchmarkConfig | None = None, data: BenchmarkData | None = None): super().__init__() self.config = config or load_config() self.data = data or load_benchmark_data(self.config.data_dir) self._rng = np.random.default_rng(self.config.seed) if self.config.action_mode == "discrete": self.action_space = spaces.Discrete(len(discrete_action_grid(self.config))) else: self.action_space = spaces.Box(low=0.0, high=1.0, shape=(3,), dtype=np.float32) self.observation_space = spaces.Box(low=-10.0, high=10.0, shape=(12,), dtype=np.float32) self._step = 0 self._episode_start_hour = 0 self._liquidity = self.config.market.initial_liquidity self._token_price = self.config.market.initial_token_price self._peak_price = self._token_price self._peak_liquidity = self._liquidity self._prev_action = self._static_actual_action() self._city_rewards = {city: 0.0 for city in self.data.cities} self._last_info: dict[str, Any] = {} def reset(self, *, seed: int | None = None, options: dict[str, Any] | None = None): super().reset(seed=seed) if seed is not None: self._rng = np.random.default_rng(seed) self._step = 0 self._episode_start_hour = self._sample_episode_start_hour(options) self._liquidity = self.config.market.initial_liquidity self._token_price = self.config.market.initial_token_price self._peak_price = self._token_price self._peak_liquidity = self._liquidity self._prev_action = self._static_actual_action() self._city_rewards = {city: 0.0 for city in self.data.cities} self._last_info = {} return self._observation(), {} def step(self, action): actual = self._decode_action(action) reward_ratio, liquidity_ratio, burn_rate = map(float, actual) absolute_hour = self._current_absolute_hour() hour = absolute_hour % 24 rows = self.data.city_hour[self.data.city_hour["absolute_hour"].eq(absolute_hour)] verified_mwh = float(rows["verified_W"].sum() / 1_000_000.0) reported_mwh = float(rows["reported_W"].sum() / 1_000_000.0) pmax_mwh = float(rows["pmax_W"].sum() / 1_000_000.0) excess_mwh = float(rows["physics_excess_W"].sum() / 1_000_000.0) rejected_reported_mwh = float(rows["rejected_reported_W"].sum() / 1_000_000.0) raw_physics_record_rate = float(rows["violation_count"].sum() / max(rows["record_count"].sum(), 1)) trade_rows = self.data.trades[self.data.trades["absolute_hour"].eq(absolute_hour)] demand_mwh = float(trade_rows["energy_purchased_MW"].sum()) if demand_mwh <= 0: market_hour = self.data.market[self.data.market["absolute_hour"].eq(absolute_hour)] demand_mwh = max(float(market_hour["total_verified_MW"].sum()), 0.001) unsafe_supply = max(rejected_reported_mwh, excess_mwh, max(reported_mwh - pmax_mwh, 0.0)) backing_pressure = min( reward_ratio + liquidity_ratio, self.config.market.max_total_allocation, ) / max(self.config.market.max_total_allocation, 1e-9) unsafe_backed_mwh = unsafe_supply * backing_pressure backed_supply_mwh = verified_mwh + unsafe_backed_mwh physics_rate = unsafe_backed_mwh / max(backed_supply_mwh, 1e-9) liquidity_added = backed_supply_mwh * liquidity_ratio reward_tokens = backed_supply_mwh * reward_ratio effective_demand = demand_mwh * max(0.75, 1.0 - 0.80 * burn_rate) available = self._liquidity + liquidity_added matched = min(available, effective_demand) unmet = max(effective_demand - available, 0.0) self._liquidity = max(available - matched, 0.0) self._peak_liquidity = max(self._peak_liquidity, self._liquidity) liquidity_drawdown = 1.0 - self._liquidity / max(self._peak_liquidity, 1e-12) slippage = float(effective_demand / max(available + 0.05, 0.05)) action_delta = float(np.linalg.norm(actual - self._prev_action, ord=1)) supply_gap = (verified_mwh - effective_demand) / max(effective_demand, 1e-6) price_return = ( 0.04 * supply_gap + 0.03 * matched + 0.10 * burn_rate - 0.08 * slippage - 0.02 * reward_tokens + float(self._rng.normal(0.0, 0.004)) ) price_return = float(np.clip(price_return, -0.35, 0.35)) self._token_price = max(0.05, self._token_price * (1.0 + price_return)) self._peak_price = max(self._peak_price, self._token_price) token_drawdown = 1.0 - self._token_price / max(self._peak_price, 1e-12) city_rewards = self._allocate_city_rewards(rows, reward_tokens, liquidity_ratio) for city, value in city_rewards.items(): self._city_rewards[city] += value fairness_variance = float(np.var(list(city_rewards.values()))) if city_rewards else 0.0 physics_penalty = 0.0 if self.config.no_physics_penalty else self.config.reward.physics_penalty * (physics_rate + unsafe_backed_mwh) reward = ( matched - self.config.reward.drawdown_penalty * liquidity_drawdown - self.config.reward.action_jitter_penalty * action_delta - self.config.reward.unmet_demand_penalty * unmet - self.config.reward.fairness_penalty * fairness_variance - physics_penalty ) self._prev_action = actual self._step += 1 truncated = self._step >= self.config.episode_steps terminated = False self._last_info = { "absolute_hour": absolute_hour, "episode_start_hour": self._episode_start_hour, "hour": hour, "reward_ratio": reward_ratio, "liquidity_ratio": liquidity_ratio, "burn_rate": burn_rate, "verified_supply_MWh": verified_mwh, "reported_supply_MWh": reported_mwh, "physics_excess_MWh": unsafe_supply, "unsafe_backed_MWh": unsafe_backed_mwh, "artificial_liquidity_MWh": unsafe_backed_mwh * liquidity_ratio, "physics_violation_rate": physics_rate, "raw_physics_record_rate": raw_physics_record_rate, "demand_MWh": demand_mwh, "matched_energy_MWh": matched, "unmet_demand_MWh": unmet, "liquidity": self._liquidity, "liquidity_depth": self._liquidity / max(self.config.market.initial_liquidity, 1e-9), "token_price": self._token_price, "max_drawdown": liquidity_drawdown, "token_drawdown": token_drawdown, "action_jitter": action_delta, "slippage": slippage, "city_rewards": city_rewards, } return self._observation(), float(reward), terminated, truncated, dict(self._last_info) def _decode_action(self, action) -> np.ndarray: if self.config.action_mode == "discrete": return decode_discrete_action(int(action), self.config) return decode_continuous_action(np.asarray(action, dtype=np.float32), self.config) def _sample_episode_start_hour(self, options: dict[str, Any] | None = None) -> int: if options and "start_hour" in options: start_hour = int(options["start_hour"]) upper_bound = max(self.data.hour_count - self.config.episode_steps, 0) return int(np.clip(start_hour, 0, upper_bound)) if self.data.hour_count <= self.config.episode_steps: return 0 latest_start = self.data.hour_count - self.config.episode_steps daily_starts = np.arange(0, latest_start + 1, 24, dtype=np.int64) if len(daily_starts) == 0: return 0 return int(self._rng.choice(daily_starts)) def _current_absolute_hour(self) -> int: if self.data.hour_count <= 0: return self._episode_start_hour + self._step return min(self._episode_start_hour + self._step, self.data.hour_count - 1) def _allocate_city_rewards(self, rows, reward_tokens: float, liquidity_ratio: float) -> dict[str, float]: total_verified = max(float(rows["verified_W"].sum()), 1e-9) city_rewards: dict[str, float] = {} for row in rows.to_dict("records"): city = str(row["city"]) share = float(row["verified_W"]) / total_verified trust_discount = 1.0 - float(row["violation_rate"]) city_rewards[city] = reward_tokens * share * trust_discount + liquidity_ratio * share * 0.01 return city_rewards def _observation(self) -> np.ndarray: absolute_hour = self._current_absolute_hour() hour = absolute_hour % 24 rows = self.data.city_hour[self.data.city_hour["absolute_hour"].eq(absolute_hour)] market = self.data.market[self.data.market["absolute_hour"].eq(absolute_hour)] verified_mwh = float(rows["verified_W"].sum() / 1_000_000.0) reported_mwh = float(rows["reported_W"].sum() / 1_000_000.0) pmax_mwh = float(rows["pmax_W"].sum() / 1_000_000.0) violation_rate = float(rows["violation_count"].sum() / max(rows["record_count"].sum(), 1)) demand_mwh = float(self.data.trades[self.data.trades["absolute_hour"].eq(absolute_hour)]["energy_purchased_MW"].sum()) static_slippage = float(market["slippage_solarchain_pct"].mean()) if not market.empty else 0.0 gap = (verified_mwh - demand_mwh) / max(demand_mwh, 1e-6) obs = np.array( [ float(np.sin(2 * np.pi * hour / 24)), float(np.cos(2 * np.pi * hour / 24)), verified_mwh, reported_mwh, pmax_mwh, gap, self._liquidity, self._token_price, violation_rate, static_slippage, float(self._prev_action[0]), float(self._prev_action[1]), ], dtype=np.float32, ) return np.clip(obs, -10.0, 10.0) def _static_actual_action(self) -> np.ndarray: return np.array( [ self.config.market.static_reward_ratio, self.config.market.static_liquidity_ratio, self.config.market.static_burn_rate, ], dtype=np.float32, ) def latest_info(self) -> dict[str, Any]: return dict(self._last_info) def city_rewards(self) -> dict[str, float]: return dict(self._city_rewards)