asdasd

custom/apps/mining-checker/src/Domain/FxService.php

@@ -0,0 +1,980 @@
+<?php
+declare(strict_types=1);
+
+namespace Modules\MiningChecker\Domain;
+
+use Modules\FxRates\Domain\FxRatesService as SharedFxRatesService;
+use Modules\FxRates\Infrastructure\ConnectionFactory as SharedFxConnectionFactory;
+use Modules\FxRates\Infrastructure\FxRatesRepository as SharedFxRatesRepository;
+use Modules\FxRates\Infrastructure\ModuleConfig as SharedFxModuleConfig;
+use Modules\FxRates\Infrastructure\SettingsStore as SharedFxSettingsStore;
+use Modules\MiningChecker\Infrastructure\MiningRepository;
+use Modules\MiningChecker\Support\DebugTrace;
+
+final class FxService
+{
+    private ?MiningRepository $repository;
+    private string $provider;
+    private string $apiBaseUrl;
+    private string $currenciesApiBaseUrl;
+    private string $apiKey;
+    private int $timeout;
+    private int $cacheTtl;
+    private bool $autoFetchOnMiss;
+    private array $memoryCache = [];
+    private array $snapshotCache = [];
+    private ?DebugTrace $debug;
+    private bool $sharedServiceResolved = false;
+    private ?object $sharedService = null;
+
+    public function __construct(
+        ?MiningRepository $repository = null,
+        string $apiBaseUrl = 'https://currencyapi.net',
+        string $currenciesApiBaseUrl = 'https://currencyapi.net',
+        int $timeout = 10,
+        int $cacheTtl = 21600,
+        bool $autoFetchOnMiss = false,
+        string $provider = 'currencyapi',
+        string $apiKey = '',
+        ?DebugTrace $debug = null
+    )
+    {
+        $this->repository = $repository;
+        $this->provider = trim(strtolower($provider)) !== '' ? trim(strtolower($provider)) : 'currencyapi';
+        $this->apiBaseUrl = rtrim($apiBaseUrl, '/');
+        $this->currenciesApiBaseUrl = rtrim($currenciesApiBaseUrl, '/');
+        $this->apiKey = trim($apiKey);
+        $this->timeout = max(2, $timeout);
+        $this->cacheTtl = max(60, $cacheTtl);
+        $this->autoFetchOnMiss = $autoFetchOnMiss;
+        $this->debug = $debug;
+    }
+
+    public function convert(?float $amount, ?string $from, ?string $to): ?float
+    {
+        return $this->convertAt($amount, $from, $to, null, null, null);
+    }
+
+    public function convertAt(?float $amount, ?string $from, ?string $to, ?string $at = null, ?int $windowMinutes = null, ?int $fetchId = null): ?float
+    {
+        if ($amount === null || $from === null || $to === null) {
+            return null;
+        }
+
+        $normalizedFetchId = $fetchId !== null && $fetchId > 0 ? $fetchId : null;
+        $shared = $this->sharedFxService();
+        if ($shared !== null && $normalizedFetchId !== null) {
+            $snapshot = $this->snapshotByFetchId($normalizedFetchId, strtoupper(trim((string) $from)), [strtoupper(trim((string) $to))]);
+            if (is_array($snapshot)) {
+                $resolved = $this->resolveRateFromSnapshot($snapshot, strtoupper(trim((string) $from)), strtoupper(trim((string) $to)));
+                if ($resolved !== null) {
+                    return $amount * $resolved;
+                }
+            }
+        }
+
+        if ($shared !== null && method_exists($shared, 'convert')) {
+            $converted = $shared->convert($amount, $from, $to, $at, $windowMinutes);
+            return is_numeric($converted) ? (float) $converted : null;
+        }
+
+        $rate = $this->rateAt($from, $to, $at, $windowMinutes, $normalizedFetchId);
+        return $rate === null ? null : $amount * $rate;
+    }
+
+    public function rate(?string $from, ?string $to): ?float
+    {
+        return $this->rateAt($from, $to, null, null, null);
+    }
+
+    public function rateAt(?string $from, ?string $to, ?string $at = null, ?int $windowMinutes = null, ?int $fetchId = null): ?float
+    {
+        $base = strtoupper(trim((string) $from));
+        $target = strtoupper(trim((string) $to));
+        $normalizedFetchId = $fetchId !== null && $fetchId > 0 ? $fetchId : null;
+
+        if ($base === '' || $target === '') {
+            return null;
+        }
+
+        if ($base === $target) {
+            return 1.0;
+        }
+
+        $shared = $this->sharedFxService();
+        if ($shared !== null && $normalizedFetchId !== null) {
+            $snapshot = $this->snapshotByFetchId($normalizedFetchId, $base, [$target]);
+            if (is_array($snapshot)) {
+                $resolved = $this->resolveRateFromSnapshot($snapshot, $base, $target);
+                if ($resolved !== null) {
+                    return $resolved;
+                }
+            }
+        }
+        if ($shared !== null && method_exists($shared, 'findRate')) {
+            $resolved = $shared->findRate($from, $to, $at, $windowMinutes);
+            return is_array($resolved) && is_numeric($resolved['rate'] ?? null) ? (float) $resolved['rate'] : null;
+        }
+
+        $cacheKey = implode(':', [$base, $target, $at ?? '', (string) ($windowMinutes ?? 0), (string) ($normalizedFetchId ?? 0)]);
+        if (array_key_exists($cacheKey, $this->memoryCache)) {
+            return $this->memoryCache[$cacheKey];
+        }
+
+        $stored = $this->storedRate($base, $target);
+        if ($stored !== null) {
+            $this->memoryCache[$cacheKey] = $stored;
+            return $stored;
+        }
+
+        $cached = $this->readFileCache($cacheKey);
+        if ($cached !== null) {
+            $this->memoryCache[$cacheKey] = $cached;
+            return $cached;
+        }
+
+        if (!$this->autoFetchOnMiss) {
+            return null;
+        }
+
+        $rate = $this->fetchAndPersistRate($base, $target);
+        $this->memoryCache[$cacheKey] = $rate;
+        if ($rate !== null) {
+            $this->writeFileCache($cacheKey, $rate);
+        }
+
+        return $rate;
+    }
+
+    public function snapshotByFetchId(int $fetchId, ?string $baseCurrency = null, ?array $symbols = null): ?array
+    {
+        if ($fetchId <= 0) {
+            return null;
+        }
+
+        $cacheKey = $this->snapshotCacheKey('fetch', [
+            $fetchId,
+            strtoupper(trim((string) ($baseCurrency ?? ''))),
+            $this->normalizeSymbolsForCache($symbols),
+        ]);
+        if (array_key_exists($cacheKey, $this->snapshotCache)) {
+            return $this->snapshotCache[$cacheKey];
+        }
+
+        $shared = $this->sharedFxService();
+        if ($shared !== null && method_exists($shared, 'snapshotByFetchId')) {
+            $snapshot = $shared->snapshotByFetchId($fetchId, $baseCurrency, $symbols);
+            return $this->snapshotCache[$cacheKey] = (is_array($snapshot) ? $snapshot : null);
+        }
+
+        return $this->snapshotCache[$cacheKey] = null;
+    }
+
+    public function latestSnapshot(?string $baseCurrency = null, ?array $symbols = null): ?array
+    {
+        $cacheKey = $this->snapshotCacheKey('latest', [
+            strtoupper(trim((string) ($baseCurrency ?? ''))),
+            $this->normalizeSymbolsForCache($symbols),
+        ]);
+        if (array_key_exists($cacheKey, $this->snapshotCache)) {
+            return $this->snapshotCache[$cacheKey];
+        }
+
+        $shared = $this->sharedFxService();
+        if ($shared !== null && method_exists($shared, 'snapshot')) {
+            $snapshot = $shared->snapshot($baseCurrency, null, $symbols, null);
+            return $this->snapshotCache[$cacheKey] = (is_array($snapshot) ? $snapshot : null);
+        }
+
+        return $this->snapshotCache[$cacheKey] = null;
+    }
+
+    public function nearestSnapshot(?string $baseCurrency, string $at, ?array $symbols = null, ?int $windowMinutes = null): ?array
+    {
+        $cacheKey = $this->snapshotCacheKey('nearest', [
+            strtoupper(trim((string) ($baseCurrency ?? ''))),
+            trim($at),
+            $windowMinutes ?? 0,
+            $this->normalizeSymbolsForCache($symbols),
+        ]);
+        if (array_key_exists($cacheKey, $this->snapshotCache)) {
+            return $this->snapshotCache[$cacheKey];
+        }
+
+        $shared = $this->sharedFxService();
+        if ($shared !== null && method_exists($shared, 'nearestSnapshot')) {
+            $snapshot = $shared->nearestSnapshot($baseCurrency, $at, $symbols, $windowMinutes);
+            return $this->snapshotCache[$cacheKey] = (is_array($snapshot) ? $snapshot : null);
+        }
+
+        return $this->snapshotCache[$cacheKey] = null;
+    }
+
+    public function refreshLatestRates(?array $currencies = null, string $base = 'EUR'): array
+    {
+        $shared = $this->sharedFxService();
+        if ($shared !== null && method_exists($shared, 'refreshLatestRates')) {
+            return $shared->refreshLatestRates($currencies, $base);
+        }
+
+        $normalizedBase = strtoupper(trim($base));
+        $targets = $currencies === null
+            ? null
+            : array_values(array_unique(array_filter(array_map(
+                static fn ($code): string => strtoupper(trim((string) $code)),
+                $currencies
+            ), static fn (string $code): bool => $code !== '' && $code !== $normalizedBase)));
+
+        $payload = $this->fetchLatestPayload($normalizedBase, $targets);
+        $rates = is_array($payload['rates'] ?? null) ? $payload['rates'] : [];
+        $rateDate = $this->normalizeRateDate($payload['date'] ?? null);
+        $forwardRates = [];
+        foreach ($rates as $target => $rate) {
+            if (!is_numeric($rate)) {
+                continue;
+            }
+            $targetCode = strtoupper((string) $target);
+            if ($targetCode === '' || $targetCode === $normalizedBase) {
+                continue;
+            }
+            $forwardRates[$targetCode] = (float) $rate;
+        }
+
+        $updated = $this->persistRateSet($normalizedBase, $forwardRates, $rateDate);
+
+        return [
+            'base' => $normalizedBase,
+            'rate_date' => $rateDate,
+            'updated_count' => count($updated),
+            'rates' => $updated,
+        ];
+    }
+
+    public function ensureFreshLatestRates(float $maxAgeHours = 3.0, string $base = 'USD'): array
+    {
+        $shared = $this->sharedFxService();
+        if ($shared !== null && method_exists($shared, 'ensureFreshLatestRates')) {
+            return $shared->ensureFreshLatestRates($maxAgeHours, $base, null);
+        }
+
+        $normalizedBase = strtoupper(trim($base));
+        $maxAgeHours = $maxAgeHours > 0 ? $maxAgeHours : 3.0;
+
+        if ($this->repository === null) {
+            return $this->refreshLatestRates(null, $normalizedBase);
+        }
+
+        $latestFetch = $this->repository->getLatestFxFetch($normalizedBase);
+        $latestFetchedAt = is_array($latestFetch) ? $this->parseStoredUtcTimestamp((string) ($latestFetch['fetched_at'] ?? '')) : null;
+        $ageSeconds = $latestFetchedAt !== null ? (time() - $latestFetchedAt) : null;
+        $maxAgeSeconds = (int) round($maxAgeHours * 3600);
+
+        if ($ageSeconds !== null && $ageSeconds >= 0 && $ageSeconds <= $maxAgeSeconds) {
+            $this->debug?->add('fx.latest.reuse', [
+                'base' => $normalizedBase,
+                'fetched_at' => $latestFetch['fetched_at'] ?? null,
+                'age_seconds' => $ageSeconds,
+                'max_age_seconds' => $maxAgeSeconds,
+            ]);
+
+            return [
+                'base' => $normalizedBase,
+                'rate_date' => $latestFetch['rate_date'] ?? null,
+                'updated_count' => 0,
+                'rates' => [],
+                'reused' => true,
+                'fetched_at' => $latestFetch['fetched_at'] ?? null,
+            ];
+        }
+
+        $this->debug?->add('fx.latest.refresh_required', [
+            'base' => $normalizedBase,
+            'previous_fetched_at' => $latestFetch['fetched_at'] ?? null,
+            'age_seconds' => $ageSeconds,
+            'max_age_seconds' => $maxAgeSeconds,
+        ]);
+
+        $result = $this->refreshLatestRates(null, $normalizedBase);
+        $result['reused'] = false;
+        return $result;
+    }
+
+    public function probeLatestRates(string $base = 'EUR'): array
+    {
+        $shared = $this->sharedFxService();
+        if ($shared !== null && method_exists($shared, 'probeLatestRates')) {
+            return $shared->probeLatestRates($base);
+        }
+
+        $normalizedBase = strtoupper(trim($base));
+        return $this->fetchLatestProbe($normalizedBase);
+    }
+
+    public function refreshCurrencyCatalog(): array
+    {
+        $shared = $this->sharedFxService();
+        if ($shared !== null && method_exists($shared, 'refreshCurrencyCatalog')) {
+            return $shared->refreshCurrencyCatalog();
+        }
+
+        $payload = $this->fetchCurrenciesPayload();
+        $items = is_array($payload['currencies'] ?? null) ? $payload['currencies'] : [];
+        if ($items === []) {
+            return [
+                'synced_count' => 0,
+                'currencies' => [],
+            ];
+        }
+
+        $synced = [];
+        $sortOrder = 1000;
+
+        foreach ($items as $code => $name) {
+            $normalizedCode = strtoupper(trim((string) $code));
+            $normalizedName = trim((string) $name);
+            if ($normalizedCode === '' || $normalizedName === '') {
+                continue;
+            }
+
+            $currency = [
+                'code' => substr($normalizedCode, 0, 10),
+                'name' => function_exists('mb_substr') ? mb_substr($normalizedName, 0, 64) : substr($normalizedName, 0, 64),
+                'symbol' => substr($normalizedCode, 0, 8),
+                'is_active' => 1,
+                'is_crypto' => $this->isCryptoCode($normalizedCode) ? 1 : 0,
+                'sort_order' => $this->catalogSortOrder($normalizedCode, $sortOrder),
+            ];
+
+            $synced[] = $currency;
+            $sortOrder++;
+        }
+
+        usort($synced, static function (array $left, array $right): int {
+            return [$left['sort_order'], $left['code']] <=> [$right['sort_order'], $right['code']];
+        });
+
+        return [
+            'synced_count' => count($synced),
+            'currencies' => $synced,
+        ];
+    }
+
+    public function probeCurrencyCatalog(): array
+    {
+        $shared = $this->sharedFxService();
+        if ($shared !== null && method_exists($shared, 'probeCurrencyCatalog')) {
+            return $shared->probeCurrencyCatalog();
+        }
+
+        return $this->fetchCurrenciesProbe();
+    }
+
+    private function fetchAndPersistRate(string $base, string $target): ?float
+    {
+        $payload = $this->fetchLatestPayload($base, [$target]);
+        $rates = is_array($payload['rates'] ?? null) ? $payload['rates'] : [];
+        $rate = $rates[$target] ?? null;
+        if (!is_numeric($rate)) {
+            return null;
+        }
+
+        $numericRate = (float) $rate;
+        $rateDate = $this->normalizeRateDate($payload['date'] ?? null);
+        $this->persistRateSet($base, [$target => $numericRate], $rateDate);
+        return $numericRate;
+    }
+
+    private function fetchLatestPayload(string $base, ?array $targets = null): array
+    {
+        if (!function_exists('curl_init')) {
+            return [];
+        }
+
+        $url = $this->buildLatestUrl($base, $targets);
+        if ($url === null) {
+            $this->debug?->add('fx.latest.skip', ['reason' => 'missing_url_or_key', 'base' => $base]);
+            return [];
+        }
+
+        $this->debug?->add('fx.latest.request', [
+            'base' => $base,
+            'url' => $this->maskUrl($url),
+            'targets' => $targets,
+        ]);
+
+        $ch = curl_init();
+        curl_setopt_array($ch, [
+            CURLOPT_URL => $url,
+            CURLOPT_RETURNTRANSFER => true,
+            CURLOPT_FOLLOWLOCATION => true,
+            CURLOPT_TIMEOUT => $this->timeout,
+            CURLOPT_HTTPHEADER => ['Accept: application/json'],
+        ]);
+
+        $response = curl_exec($ch);
+        $httpStatus = (int) curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
+        $curlError = curl_error($ch);
+        curl_close($ch);
+
+        $this->debug?->add('fx.latest.response', [
+            'http_status' => $httpStatus,
+            'curl_error' => $curlError,
+            'response_bytes' => is_string($response) ? strlen($response) : 0,
+            'response_preview' => is_string($response) ? substr($response, 0, 1200) : null,
+        ]);
+
+        if ($response === false || $curlError !== '' || $httpStatus >= 400) {
+            return [];
+        }
+
+        $payload = json_decode((string) $response, true);
+        return $this->normalizePayload($payload, $base, $targets);
+    }
+
+    private function fetchLatestProbe(string $base): array
+    {
+        if (!function_exists('curl_init')) {
+            return ['ok' => false, 'message' => 'curl_init ist nicht verfuegbar.'];
+        }
+
+        $url = $this->buildLatestUrl($base, null);
+        if ($url === null) {
+            return ['ok' => false, 'message' => 'FX-URL oder API-Key fehlt.'];
+        }
+
+        $this->debug?->add('fx.latest.probe.request', [
+            'base' => $base,
+            'url' => $this->maskUrl($url),
+        ]);
+
+        $ch = curl_init();
+        curl_setopt_array($ch, [
+            CURLOPT_URL => $url,
+            CURLOPT_RETURNTRANSFER => true,
+            CURLOPT_FOLLOWLOCATION => true,
+            CURLOPT_TIMEOUT => $this->timeout,
+            CURLOPT_HEADER => true,
+            CURLOPT_HTTPHEADER => ['Accept: application/json'],
+        ]);
+
+        $response = curl_exec($ch);
+        $httpStatus = (int) curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
+        $headerSize = (int) curl_getinfo($ch, CURLINFO_HEADER_SIZE);
+        $curlError = curl_error($ch);
+        curl_close($ch);
+
+        $rawHeaders = is_string($response) ? substr($response, 0, $headerSize) : '';
+        $body = is_string($response) ? substr($response, $headerSize) : '';
+
+        $result = [
+            'ok' => $response !== false && $curlError === '' && $httpStatus < 400,
+            'url' => $this->maskUrl($url),
+            'http_status' => $httpStatus,
+            'curl_error' => $curlError,
+            'response_headers' => $rawHeaders,
+            'response_body' => substr($body, 0, 4000),
+        ];
+
+        $this->debug?->add('fx.latest.probe.response', $result);
+        return $result;
+    }
+
+    private function fetchCurrenciesPayload(): array
+    {
+        if (!function_exists('curl_init') || $this->apiKey === '') {
+            return [];
+        }
+
+        $url = sprintf(
+            '%s/api/v2/currencies?output=json&key=%s',
+            $this->currenciesApiBaseUrl,
+            rawurlencode($this->apiKey)
+        );
+
+        $this->debug?->add('fx.currencies.request', [
+            'url' => $this->maskUrl($url),
+        ]);
+
+        $ch = curl_init();
+        curl_setopt_array($ch, [
+            CURLOPT_URL => $url,
+            CURLOPT_RETURNTRANSFER => true,
+            CURLOPT_FOLLOWLOCATION => true,
+            CURLOPT_TIMEOUT => $this->timeout,
+            CURLOPT_HTTPHEADER => ['Accept: application/json'],
+        ]);
+
+        $response = curl_exec($ch);
+        $httpStatus = (int) curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
+        $curlError = curl_error($ch);
+        curl_close($ch);
+
+        $this->debug?->add('fx.currencies.response', [
+            'http_status' => $httpStatus,
+            'curl_error' => $curlError,
+            'response_bytes' => is_string($response) ? strlen($response) : 0,
+            'response_preview' => is_string($response) ? substr($response, 0, 1200) : null,
+        ]);
+
+        if ($response === false || $curlError !== '' || $httpStatus >= 400) {
+            return [];
+        }
+
+        $payload = json_decode((string) $response, true);
+        if (!is_array($payload)) {
+            throw new \RuntimeException('Waehrungskatalog konnte nicht gelesen werden.');
+        }
+
+        if (($payload['valid'] ?? false) !== true || !is_array($payload['currencies'] ?? null)) {
+            throw new \RuntimeException($this->extractProviderError($payload, 'Waehrungskatalog konnte nicht geladen werden.'));
+        }
+
+        return $payload;
+    }
+
+    private function fetchCurrenciesProbe(): array
+    {
+        if (!function_exists('curl_init') || $this->apiKey === '') {
+            return ['ok' => false, 'message' => 'curl_init oder API-Key fehlt.'];
+        }
+
+        $url = sprintf(
+            '%s/api/v2/currencies?output=json&key=%s',
+            $this->currenciesApiBaseUrl,
+            rawurlencode($this->apiKey)
+        );
+
+        $this->debug?->add('fx.currencies.probe.request', [
+            'url' => $this->maskUrl($url),
+        ]);
+
+        $ch = curl_init();
+        curl_setopt_array($ch, [
+            CURLOPT_URL => $url,
+            CURLOPT_RETURNTRANSFER => true,
+            CURLOPT_FOLLOWLOCATION => true,
+            CURLOPT_TIMEOUT => $this->timeout,
+            CURLOPT_HEADER => true,
+            CURLOPT_HTTPHEADER => ['Accept: application/json'],
+        ]);
+
+        $response = curl_exec($ch);
+        $httpStatus = (int) curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
+        $headerSize = (int) curl_getinfo($ch, CURLINFO_HEADER_SIZE);
+        $curlError = curl_error($ch);
+        curl_close($ch);
+
+        $rawHeaders = is_string($response) ? substr($response, 0, $headerSize) : '';
+        $body = is_string($response) ? substr($response, $headerSize) : '';
+
+        $result = [
+            'ok' => $response !== false && $curlError === '' && $httpStatus < 400,
+            'url' => $this->maskUrl($url),
+            'http_status' => $httpStatus,
+            'curl_error' => $curlError,
+            'response_headers' => $rawHeaders,
+            'response_body' => substr($body, 0, 4000),
+        ];
+
+        $this->debug?->add('fx.currencies.probe.response', $result);
+        return $result;
+    }
+
+    private function storedRate(string $base, string $target): ?float
+    {
+        if ($this->repository === null) {
+            return null;
+        }
+
+        try {
+            $direct = $this->repository->getLatestFxRate($base, $target);
+            if (is_array($direct) && is_numeric($direct['rate'] ?? null)) {
+                return (float) $direct['rate'];
+            }
+
+            $inverse = $this->repository->getLatestFxRate($target, $base);
+            if (is_array($inverse) && is_numeric($inverse['rate'] ?? null) && (float) $inverse['rate'] > 0) {
+                return 1 / (float) $inverse['rate'];
+            }
+
+            $measurementRate = $this->repository->getLatestMeasurementRate($base, $target);
+            if (is_array($measurementRate) && is_numeric($measurementRate['rate'] ?? null)) {
+                return (float) $measurementRate['rate'];
+            }
+
+            $inverseMeasurementRate = $this->repository->getLatestMeasurementRate($target, $base);
+            if (
+                is_array($inverseMeasurementRate) &&
+                is_numeric($inverseMeasurementRate['rate'] ?? null) &&
+                (float) $inverseMeasurementRate['rate'] > 0
+            ) {
+                return 1 / (float) $inverseMeasurementRate['rate'];
+            }
+
+            foreach (['USD', 'EUR'] as $viaBase) {
+                if ($base === $viaBase || $target === $viaBase) {
+                    continue;
+                }
+
+                $fromVia = $this->repository->getLatestFxRate($viaBase, $base);
+                $toVia = $this->repository->getLatestFxRate($viaBase, $target);
+                if (
+                    is_array($fromVia) && is_numeric($fromVia['rate'] ?? null) &&
+                    is_array($toVia) && is_numeric($toVia['rate'] ?? null) &&
+                    (float) $fromVia['rate'] > 0
+                ) {
+                    return (float) $toVia['rate'] / (float) $fromVia['rate'];
+                }
+
+                $fromViaInverse = $this->repository->getLatestFxRate($base, $viaBase);
+                $toViaInverse = $this->repository->getLatestFxRate($target, $viaBase);
+                if (
+                    is_array($fromViaInverse) && is_numeric($fromViaInverse['rate'] ?? null) &&
+                    is_array($toViaInverse) && is_numeric($toViaInverse['rate'] ?? null) &&
+                    (float) $toViaInverse['rate'] > 0
+                ) {
+                    return (1 / (float) $fromViaInverse['rate']) / (1 / (float) $toViaInverse['rate']);
+                }
+            }
+        } catch (\Throwable) {
+            return null;
+        }
+
+        return null;
+    }
+
+    private function persistRateSet(string $base, array $rates, string $rateDate): array
+    {
+        $normalizedBase = strtoupper($base);
+        $normalizedRates = [];
+        foreach ($rates as $target => $rate) {
+            if (!is_numeric($rate)) {
+                continue;
+            }
+
+            $normalizedTarget = strtoupper((string) $target);
+            $normalizedRates[$normalizedTarget] = (float) $rate;
+            $this->memoryCache[$normalizedBase . ':' . $normalizedTarget] = (float) $rate;
+            $this->writeFileCache($normalizedBase . ':' . $normalizedTarget, (float) $rate);
+        }
+
+        if ($this->repository === null) {
+            $result = [];
+            foreach ($normalizedRates as $target => $rate) {
+                $result[] = [
+                    'base_currency' => $normalizedBase,
+                    'target_currency' => $target,
+                    'rate' => $rate,
+                    'rate_date' => $rateDate,
+                    'provider' => $this->provider,
+                ];
+            }
+            return $result;
+        }
+
+        try {
+            $saved = $this->repository->saveFxFetch($normalizedBase, $this->provider, $rateDate, $normalizedRates);
+            return is_array($saved['rates'] ?? null) ? $saved['rates'] : [];
+        } catch (\Throwable) {
+            $result = [];
+            foreach ($normalizedRates as $target => $rate) {
+                $result[] = [
+                    'base_currency' => $normalizedBase,
+                    'target_currency' => $target,
+                    'rate' => $rate,
+                    'rate_date' => $rateDate,
+                    'provider' => $this->provider,
+                ];
+            }
+            return $result;
+        }
+    }
+
+    private function buildLatestUrl(string $base, ?array $targets = null): ?string
+    {
+        if ($this->provider === 'currencyapi') {
+            if ($this->apiKey === '') {
+                return null;
+            }
+
+            return sprintf(
+                '%s/api/v2/rates?base=%s&output=json&key=%s',
+                $this->apiBaseUrl,
+                rawurlencode($base),
+                rawurlencode($this->apiKey)
+            );
+        }
+
+        $targets = $targets ?? $this->defaultCurrencies();
+        return sprintf(
+            '%s/latest?base=%s&symbols=%s',
+            $this->apiBaseUrl,
+            rawurlencode($base),
+            rawurlencode(implode(',', $targets))
+        );
+    }
+
+    private function normalizePayload(mixed $payload, string $base, ?array $targets = null): array
+    {
+        if (!is_array($payload)) {
+            return [];
+        }
+
+        if ($this->provider === 'currencyapi') {
+            if (($payload['valid'] ?? false) !== true || !is_array($payload['rates'] ?? null)) {
+                throw new \RuntimeException($this->extractProviderError($payload, 'FX-Kurse konnten nicht geladen werden.'));
+            }
+
+            $allRates = $payload['rates'];
+            $filteredRates = [];
+            if ($targets === null) {
+                foreach ($allRates as $target => $rate) {
+                    $targetCode = strtoupper((string) $target);
+                    if ($targetCode === $base || !is_numeric($rate)) {
+                        continue;
+                    }
+                    $filteredRates[$targetCode] = (float) $rate;
+                }
+            } else {
+                foreach ($targets as $target) {
+                    $targetCode = strtoupper((string) $target);
+                    if ($targetCode === $base) {
+                        continue;
+                    }
+
+                    $rate = $allRates[$targetCode] ?? null;
+                    if (is_numeric($rate)) {
+                        $filteredRates[$targetCode] = (float) $rate;
+                    }
+                }
+            }
+
+            return [
+                'base' => strtoupper((string) ($payload['base'] ?? $base)),
+                'date' => $payload['updated'] ?? null,
+                'rates' => $filteredRates,
+            ];
+        }
+
+        if (!is_array($payload['rates'] ?? null)) {
+            return [];
+        }
+
+        if (array_key_exists('success', $payload) && $payload['success'] !== true) {
+            return [];
+        }
+
+        return $payload;
+    }
+
+    private function extractProviderError(array $payload, string $fallback): string
+    {
+        foreach (['error', 'message', 'msg'] as $field) {
+            $value = $payload[$field] ?? null;
+            if (is_string($value) && trim($value) !== '') {
+                return trim($value);
+            }
+        }
+
+        $errors = $payload['errors'] ?? null;
+        if (is_array($errors)) {
+            $flat = [];
+            array_walk_recursive($errors, static function ($value) use (&$flat): void {
+                if (is_string($value) && trim($value) !== '') {
+                    $flat[] = trim($value);
+                }
+            });
+            if ($flat !== []) {
+                return implode(' | ', array_values(array_unique($flat)));
+            }
+        }
+
+        return $fallback;
+    }
+
+    private function defaultCurrencies(): array
+    {
+        return ['EUR', 'USD'];
+    }
+
+    private function normalizeRateDate(mixed $value): string
+    {
+        if (is_int($value) || is_float($value) || (is_string($value) && ctype_digit(trim($value)))) {
+            $timestamp = (int) $value;
+            if ($timestamp > 0) {
+                return date('Y-m-d', $timestamp);
+            }
+        }
+
+        if (is_string($value) && trim($value) !== '') {
+            $timestamp = strtotime($value);
+            if ($timestamp !== false) {
+                return date('Y-m-d', $timestamp);
+            }
+
+            if (preg_match('/^\d{4}-\d{2}-\d{2}/', $value, $matches) === 1) {
+                return $matches[0];
+            }
+        }
+
+        return date('Y-m-d');
+    }
+
+    private function parseStoredUtcTimestamp(string $value): ?int
+    {
+        $normalized = trim($value);
+        if ($normalized === '') {
+            return null;
+        }
+
+        try {
+            if (preg_match('/^\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}(?::\d{2})?)?$/', $normalized) === 1) {
+                $date = new \DateTimeImmutable(str_replace(' ', 'T', $normalized), new \DateTimeZone('UTC'));
+            } else {
+                $date = new \DateTimeImmutable($normalized);
+            }
+            return $date->setTimezone(new \DateTimeZone('UTC'))->getTimestamp();
+        } catch (\Throwable) {
+            return null;
+        }
+    }
+
+    private function catalogSortOrder(string $code, int $fallback): int
+    {
+        return match (strtoupper($code)) {
+            'EUR' => 10,
+            'USD' => 20,
+            'DOGE' => 30,
+            'BTC' => 40,
+            'ETH' => 50,
+            'USDT' => 60,
+            'USDC' => 70,
+            default => $fallback,
+        };
+    }
+
+    private function isCryptoCode(string $code): bool
+    {
+        return in_array(strtoupper($code), [
+            'ADA', 'ARB', 'BNB', 'BTC', 'DAI', 'DOGE', 'DOT', 'ETH', 'LINK', 'LTC',
+            'SOL', 'USDC', 'USDT', 'XRP',
+        ], true);
+    }
+
+    private function cacheFile(string $cacheKey): string
+    {
+        return rtrim(sys_get_temp_dir(), '/') . '/mining-checker-fx-' . md5($cacheKey) . '.json';
+    }
+
+    private function readFileCache(string $cacheKey): ?float
+    {
+        $file = $this->cacheFile($cacheKey);
+        if (!is_file($file) || (time() - filemtime($file)) > $this->cacheTtl) {
+            return null;
+        }
+
+        $payload = json_decode((string) file_get_contents($file), true);
+        $rate = $payload['rate'] ?? null;
+        return is_numeric($rate) ? (float) $rate : null;
+    }
+
+    private function writeFileCache(string $cacheKey, float $rate): void
+    {
+        @file_put_contents($this->cacheFile($cacheKey), json_encode([
+            'rate' => $rate,
+            'cached_at' => time(),
+        ], JSON_UNESCAPED_UNICODE));
+    }
+
+    private function maskUrl(string $url): string
+    {
+        return preg_replace_callback('/([?&]key=)([^&]+)/i', static function (array $matches): string {
+            $key = $matches[2] ?? '';
+            if (strlen($key) <= 8) {
+                return $matches[1] . $key;
+            }
+
+            return $matches[1] . substr($key, 0, 6) . '...' . substr($key, -4);
+        }, $url) ?: $url;
+    }
+
+    private function sharedFxService(): ?object
+    {
+        if ($this->sharedServiceResolved) {
+            return $this->sharedService;
+        }
+
+        try {
+            $moduleBasePath = dirname(__DIR__, 2) . '/../fx-rates';
+            $bootstrap = $moduleBasePath . '/bootstrap.php';
+            if (!is_file($bootstrap)) {
+                $this->sharedServiceResolved = true;
+                return $this->sharedService = null;
+            }
+
+            require_once $bootstrap;
+
+            if (!class_exists(SharedFxModuleConfig::class) || !class_exists(SharedFxRatesService::class)) {
+                $this->sharedServiceResolved = true;
+                return $this->sharedService = null;
+            }
+
+            $config = SharedFxModuleConfig::load($moduleBasePath);
+            $settingsStore = new SharedFxSettingsStore($config);
+            $repository = new SharedFxRatesRepository(
+                SharedFxConnectionFactory::make($settingsStore),
+                $config->tablePrefix()
+            );
+            $repository->ensureSchema();
+
+            $this->sharedServiceResolved = true;
+            return $this->sharedService = new SharedFxRatesService($repository, $settingsStore->load());
+        } catch (\Throwable) {
+            $this->sharedServiceResolved = true;
+            return $this->sharedService = null;
+        }
+    }
+
+    private function resolveRateFromSnapshot(array $snapshot, string $from, string $to): ?float
+    {
+        $base = strtoupper(trim((string) ($snapshot['base_currency'] ?? '')));
+        $rates = is_array($snapshot['rates'] ?? null) ? $snapshot['rates'] : [];
+
+        if ($base === '' || $from === '' || $to === '') {
+            return null;
+        }
+
+        if ($base === $from && is_numeric($rates[$to] ?? null)) {
+            return (float) $rates[$to];
+        }
+
+        if ($base === $to && is_numeric($rates[$from] ?? null) && (float) $rates[$from] > 0) {
+            return 1 / (float) $rates[$from];
+        }
+
+        if (is_numeric($rates[$from] ?? null) && is_numeric($rates[$to] ?? null) && (float) $rates[$from] > 0) {
+            return (float) $rates[$to] / (float) $rates[$from];
+        }
+
+        return null;
+    }
+
+    private function snapshotCacheKey(string $prefix, array $parts): string
+    {
+        return $prefix . ':' . implode(':', array_map(static fn (mixed $part): string => (string) $part, $parts));
+    }
+
+    private function normalizeSymbolsForCache(?array $symbols): string
+    {
+        if (!is_array($symbols) || $symbols === []) {
+            return '*';
+        }
+
+        $normalized = array_values(array_unique(array_filter(array_map(
+            static fn (mixed $symbol): string => strtoupper(trim((string) $symbol)),
+            $symbols
+        ))));
+        sort($normalized);
+        return implode(',', $normalized);
+    }
+}

custom/apps/mining-checker/src/Domain/OcrService.php

@@ -0,0 +1,665 @@
+<?php
+declare(strict_types=1);
+
+namespace Modules\MiningChecker\Domain;
+
+use Modules\MiningChecker\Infrastructure\ModuleConfig;
+use Modules\MiningChecker\Support\ApiException;
+
+final class OcrService
+{
+    private ModuleConfig $config;
+
+    public function __construct(ModuleConfig $config)
+    {
+        $this->config = $config;
+    }
+
+    public function preview(array $file, array $input): array
+    {
+        if (($file['error'] ?? UPLOAD_ERR_NO_FILE) !== UPLOAD_ERR_OK) {
+            throw new ApiException('Screenshot-Upload fehlt oder ist fehlerhaft.', 422);
+        }
+
+        $mime = mime_content_type($file['tmp_name']) ?: '';
+        if (!in_array($mime, ['image/png', 'image/jpeg', 'image/webp'], true)) {
+            throw new ApiException('Nur PNG, JPEG und WEBP werden akzeptiert.', 422, ['mime' => $mime]);
+        }
+
+        $projectKey = (string) ($input['project_key'] ?? $this->config->defaultProjectKey());
+        $uploadDir = $this->resolveUploadDir($projectKey);
+
+        $extension = pathinfo((string) ($file['name'] ?? 'upload.png'), PATHINFO_EXTENSION) ?: 'png';
+        $filename = date('Ymd-His') . '-' . bin2hex(random_bytes(4)) . '.' . strtolower($extension);
+        $targetFile = $uploadDir . '/' . $filename;
+        if (!move_uploaded_file($file['tmp_name'], $targetFile)) {
+            throw new ApiException('Bild konnte nicht gespeichert werden.', 500);
+        }
+
+        $rawText = trim((string) ($input['ocr_hint_text'] ?? ''));
+        $flags = [];
+
+        if ($rawText === '') {
+            ['text' => $rawText, 'flags' => $providerFlags] = $this->extractRawText($targetFile);
+            $flags = array_merge($flags, $providerFlags);
+        } else {
+            $flags[] = 'ocr_hint_text_used';
+        }
+
+        $parsed = $this->parseText(
+            $rawText,
+            (string) ($input['date_context'] ?? date('Y-m-d')),
+            strtoupper(trim((string) ($input['wallet_currency_hint'] ?? '')))
+        );
+        $parsed['image_path'] = $targetFile;
+        $parsed['raw_text'] = $rawText;
+        $parsed['flags'] = array_values(array_unique(array_merge($flags, $parsed['flags'])));
+
+        return $parsed;
+    }
+
+    private function resolveUploadDir(string $projectKey): string
+    {
+        $safeProjectKey = preg_replace('~[^a-zA-Z0-9_-]~', '-', $projectKey) ?: 'default';
+        $candidates = [
+            rtrim($this->config->uploadsDir(), '/') . '/' . $safeProjectKey,
+            rtrim(sys_get_temp_dir(), '/') . '/mining-checker/uploads/' . $safeProjectKey,
+        ];
+
+        foreach ($candidates as $candidate) {
+            if ($this->ensureWritableDirectory($candidate)) {
+                return $candidate;
+            }
+        }
+
+        throw new ApiException('Upload-Verzeichnis konnte nicht erstellt werden.', 500, [
+            'candidates' => $candidates,
+        ]);
+    }
+
+    private function ensureWritableDirectory(string $directory): bool
+    {
+        if (is_dir($directory)) {
+            return is_writable($directory);
+        }
+
+        return @mkdir($directory, 0775, true) || is_dir($directory);
+    }
+
+    private function extractRawText(string $imagePath): array
+    {
+        $ocrConfig = $this->config->ocr();
+        $providers = $ocrConfig['providers'] ?? ['tesseract'];
+        $flags = [];
+
+        if (!is_array($providers) || $providers === []) {
+            $providers = ['tesseract'];
+        }
+
+        foreach ($providers as $provider) {
+            $providerName = strtolower(trim((string) $provider));
+            if ($providerName === '') {
+                continue;
+            }
+
+            if ($providerName === 'ocrspace') {
+                $result = $this->runOcrSpace((array) ($ocrConfig['ocrspace'] ?? []), $imagePath);
+            } elseif ($providerName === 'tesseract') {
+                $result = $this->runTesseract((array) ($ocrConfig['tesseract'] ?? []), $imagePath);
+            } else {
+                $flags[] = 'ocr_provider_unsupported:' . $providerName;
+                continue;
+            }
+
+            $flags = array_merge($flags, $result['flags']);
+            if (($result['text'] ?? '') !== '') {
+                return [
+                    'text' => (string) $result['text'],
+                    'flags' => array_values(array_unique(array_merge(
+                        $flags,
+                        ['ocr_provider:' . $providerName]
+                    ))),
+                ];
+            }
+        }
+
+        return [
+            'text' => '',
+            'flags' => array_values(array_unique(array_merge($flags, ['ocr_engine_missing']))),
+        ];
+    }
+
+    private function runOcrSpace(array $providerConfig, string $imagePath): array
+    {
+        if (!function_exists('curl_init') || !class_exists(\CURLFile::class)) {
+            return [
+                'text' => '',
+                'flags' => ['ocr_provider_missing:ocrspace', 'ocr_transport_missing:curl'],
+            ];
+        }
+
+        $url = trim((string) ($providerConfig['url'] ?? ''));
+        if ($url === '') {
+            return [
+                'text' => '',
+                'flags' => ['ocr_provider_missing:ocrspace', 'ocrspace_url_missing'],
+            ];
+        }
+
+        $apiKey = trim((string) ($providerConfig['api_key'] ?? ''));
+        if ($apiKey === '') {
+            return [
+                'text' => '',
+                'flags' => ['ocr_provider_missing:ocrspace', 'ocrspace_api_key_missing'],
+            ];
+        }
+
+        $postFields = [
+            'file' => new \CURLFile($imagePath),
+            'language' => (string) ($providerConfig['language'] ?? 'eng'),
+            'OCREngine' => (string) ((int) ($providerConfig['engine'] ?? 2)),
+            'scale' => (string) ($providerConfig['scale'] ?? 'true'),
+            'detectOrientation' => (string) ($providerConfig['detect_orientation'] ?? 'true'),
+            'isTable' => (string) ($providerConfig['is_table'] ?? 'false'),
+            'isOverlayRequired' => 'false',
+        ];
+
+        $ch = curl_init();
+        curl_setopt_array($ch, [
+            CURLOPT_URL => $url,
+            CURLOPT_POST => true,
+            CURLOPT_POSTFIELDS => $postFields,
+            CURLOPT_RETURNTRANSFER => true,
+            CURLOPT_FOLLOWLOCATION => true,
+            CURLOPT_TIMEOUT => max(5, (int) ($providerConfig['timeout'] ?? 25)),
+            CURLOPT_HTTPHEADER => [
+                'Accept: application/json',
+                'apikey: ' . $apiKey,
+            ],
+        ]);
+
+        $response = curl_exec($ch);
+        $curlError = curl_error($ch);
+        $httpStatus = (int) curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
+        curl_close($ch);
+
+        if ($response === false || $curlError !== '') {
+            return [
+                'text' => '',
+                'flags' => ['ocr_provider_empty:ocrspace', 'ocrspace_request_failed'],
+            ];
+        }
+
+        $payload = json_decode((string) $response, true);
+        if (!is_array($payload)) {
+            return [
+                'text' => '',
+                'flags' => ['ocr_provider_empty:ocrspace', 'ocrspace_invalid_response'],
+            ];
+        }
+
+        $flags = [];
+        $rawText = '';
+        $parsedResults = $payload['ParsedResults'] ?? null;
+        if (is_array($parsedResults)) {
+            $texts = [];
+            foreach ($parsedResults as $result) {
+                if (!is_array($result)) {
+                    continue;
+                }
+                $fileExitCode = (string) ($result['FileParseExitCode'] ?? '');
+                if ($fileExitCode !== '') {
+                    $flags[] = 'ocrspace_file_exit_code:' . $fileExitCode;
+                }
+                $parsedText = trim((string) ($result['ParsedText'] ?? ''));
+                if ($parsedText !== '') {
+                    $texts[] = $parsedText;
+                }
+                $resultError = trim((string) ($result['ErrorMessage'] ?? ''));
+                if ($resultError !== '') {
+                    $flags[] = 'ocrspace_result_error';
+                }
+            }
+            $rawText = trim(implode("\n", $texts));
+        }
+
+        $ocrExitCode = (string) ($payload['OCRExitCode'] ?? '');
+        $isErroredOnProcessing = !empty($payload['IsErroredOnProcessing']);
+        $errorMessage = trim((string) ($payload['ErrorMessage'] ?? ''));
+        $errorDetails = trim((string) ($payload['ErrorDetails'] ?? ''));
+
+        if ($httpStatus >= 400) {
+            $flags[] = 'ocrspace_http_error';
+        }
+
+        if ($ocrExitCode !== '') {
+            $flags[] = 'ocrspace_exit_code:' . $ocrExitCode;
+        }
+
+        $flags[] = 'ocrspace_engine:' . (string) ((int) ($providerConfig['engine'] ?? 2));
+
+        if ($isErroredOnProcessing) {
+            $flags[] = 'ocrspace_processing_error';
+        }
+
+        if ($errorMessage !== '' || $errorDetails !== '') {
+            $flags[] = 'ocrspace_error';
+        }
+
+        return [
+            'text' => $rawText,
+            'flags' => $rawText === '' ? array_values(array_unique(array_merge($flags, ['ocr_provider_empty:ocrspace']))) : array_values(array_unique($flags)),
+        ];
+    }
+
+    private function runTesseract(array $providerConfig, string $imagePath): array
+    {
+        $binary = (string) ($providerConfig['binary'] ?? 'tesseract');
+        if (!$this->binaryExists($binary)) {
+            return [
+                'text' => '',
+                'flags' => ['ocr_provider_missing:tesseract'],
+            ];
+        }
+
+        $language = (string) ($providerConfig['language'] ?? 'eng');
+        $tmpBase = tempnam(sys_get_temp_dir(), 'mc-ocr-');
+        if ($tmpBase === false) {
+            return [
+                'text' => '',
+                'flags' => ['ocr_tempfile_failed:tesseract'],
+            ];
+        }
+
+        @unlink($tmpBase);
+        $command = sprintf(
+            '%s %s %s -l %s 2>/dev/null',
+            escapeshellcmd($binary),
+            escapeshellarg($imagePath),
+            escapeshellarg($tmpBase),
+            escapeshellarg($language)
+        );
+        shell_exec($command);
+
+        $txtFile = $tmpBase . '.txt';
+        $text = is_file($txtFile) ? (string) file_get_contents($txtFile) : '';
+        @unlink($txtFile);
+        return [
+            'text' => trim($text),
+            'flags' => trim($text) === '' ? ['ocr_provider_empty:tesseract'] : [],
+        ];
+    }
+
+    private function binaryExists(string $binary): bool
+    {
+        return $binary !== '' && trim((string) shell_exec('command -v ' . escapeshellarg($binary) . ' 2>/dev/null')) !== '';
+    }
+
+    private function parseText(string $rawText, string $dateContext, string $walletCurrencyHint = ''): array
+    {
+        $measurement = $this->parseMeasurementText($rawText, $dateContext);
+        $wallet = $this->parseWalletText($rawText, $dateContext, $walletCurrencyHint);
+
+        $isWallet = ($wallet['score'] ?? 0) > ($measurement['score'] ?? 0)
+            && (
+                ($wallet['suggested_wallet']['wallet_balance'] ?? null) !== null
+                || ($wallet['suggested_wallet']['total_value_amount'] ?? null) !== null
+            );
+
+        return [
+            'kind' => $isWallet ? 'wallet' : 'measurement',
+            'suggested' => $measurement['suggested'],
+            'suggested_wallet' => $wallet['suggested_wallet'],
+            'confidence' => round((float) ($isWallet ? ($wallet['confidence'] ?? 0.0) : ($measurement['confidence'] ?? 0.0)), 4),
+            'flags' => $isWallet ? $wallet['flags'] : $measurement['flags'],
+        ];
+    }
+
+    private function parseMeasurementText(string $rawText, string $dateContext): array
+    {
+        $flags = [];
+        $suggestedTime = null;
+        $coinsTotal = null;
+        $price = null;
+        $currency = null;
+        $normalizedText = preg_replace('/[[:space:]]+/u', ' ', trim($rawText)) ?: '';
+        $lines = array_values(array_filter(array_map(
+            static fn (string $line): string => trim($line),
+            preg_split('/\R/u', $rawText) ?: []
+        ), static fn (string $line): bool => $line !== ''));
+
+        if ($normalizedText === '') {
+            $flags[] = 'ocr_raw_text_empty';
+        }
+
+        if (preg_match('/\b([01]?\d|2[0-3]):([0-5]\d)\b/', $normalizedText, $timeMatch)) {
+            $suggestedTime = sprintf('%s %02d:%02d:00', $dateContext, (int) $timeMatch[1], (int) $timeMatch[2]);
+        }
+
+        preg_match_all('/\b\d+(?:[.,]\d+)?\b/', $normalizedText, $numberMatches);
+        $decimalCandidates = [];
+        foreach ($numberMatches[0] ?? [] as $candidate) {
+            $normalized = (float) str_replace(',', '.', $candidate);
+            if ($normalized <= 0) {
+                continue;
+            }
+            $decimalCandidates[] = [
+                'raw' => $candidate,
+                'value' => $normalized,
+                'precision' => str_contains($candidate, ',') || str_contains($candidate, '.')
+                    ? strlen((string) preg_replace('/^\d+[.,]/', '', $candidate))
+                    : 0,
+            ];
+        }
+
+        if (preg_match('/DOGE\s*\/\s*(USD|EUR|USDT|USDC|BTC|ETH|LTC)/i', $normalizedText, $pairMatch)) {
+            $currency = strtoupper((string) $pairMatch[1]);
+        } elseif (preg_match('/\b(EUR|USD|USDT|USDC|BTC|ETH|LTC)\b/i', $normalizedText, $currencyMatch)) {
+            $currency = strtoupper((string) $currencyMatch[1]);
+        } elseif (str_contains($normalizedText, '$')) {
+            $currency = 'USD';
+        } else {
+            $flags[] = 'currency_missing';
+        }
+
+        if (preg_match('/DOGE\s*\/\s*(?:USD|EUR|USDT|USDC|BTC|ETH|LTC)[^\d]{0,20}(\d+[.,]\d{3,8})/i', $normalizedText, $priceMatch)) {
+            $price = round((float) str_replace(',', '.', $priceMatch[1]), 8);
+        }
+
+        if ($coinsTotal === null) {
+            foreach ($lines as $line) {
+                if (!preg_match('/MINING[- ]?GUTHABEN|MINING[- ]?BALANCE|GUTHABEN|BALANCE/i', $line)) {
+                    continue;
+                }
+
+                if (preg_match('/(\d+[.,]\d{4,8})/', $line, $lineCoinsMatch)) {
+                    $coinsTotal = round((float) str_replace(',', '.', $lineCoinsMatch[1]), 6);
+                    $flags[] = 'coins_from_balance_line';
+                    break;
+                }
+            }
+        }
+
+        if ($coinsTotal === null && preg_match('/(\d+[.,]\d{4,8})\s*(?:DOGE)?\s*(?:MINING[- ]?GUTHABEN|MINING[- ]?BALANCE|GUTHABEN|BALANCE)/i', $normalizedText, $coinsMatch)) {
+            $coinsTotal = round((float) str_replace(',', '.', $coinsMatch[1]), 6);
+            $flags[] = 'coins_from_balance_context';
+        }
+
+        if ($coinsTotal === null) {
+            $coinsCandidates = array_values(array_filter($decimalCandidates, static function (array $item) use ($price): bool {
+                if ($item['precision'] < 4) {
+                    return false;
+                }
+                if ($item['value'] <= 0 || $item['value'] >= 1000000) {
+                    return false;
+                }
+                if ($price !== null && abs($item['value'] - $price) < 0.0000005) {
+                    return false;
+                }
+
+                return true;
+            }));
+
+            if ($coinsCandidates !== []) {
+                usort($coinsCandidates, static function (array $a, array $b): int {
+                    return [$b['precision'], $b['value']] <=> [$a['precision'], $a['value']];
+                });
+                $coinsTotal = round((float) $coinsCandidates[0]['value'], 6);
+                if (count($coinsCandidates) > 1) {
+                    $flags[] = 'coins_ambiguous';
+                }
+            } else {
+                $flags[] = 'coins_missing';
+            }
+        }
+
+        $priceCandidates = array_values(array_filter(
+            $decimalCandidates,
+            static fn (array $item): bool => $item['value'] > 0 && $item['value'] < 1
+        ));
+
+        if ($price === null && $priceCandidates !== []) {
+            usort($priceCandidates, static function (array $a, array $b): int {
+                return [$b['precision'], $a['value']] <=> [$a['precision'], $b['value']];
+            });
+            $price = round((float) $priceCandidates[0]['value'], 8);
+            if (count($priceCandidates) > 1 && count(array_filter($priceCandidates, static fn (array $item): bool => $item['precision'] >= 4)) > 1) {
+                $flags[] = 'price_ambiguous';
+            }
+        }
+
+        if ($price === null && $coinsTotal !== null && preg_match('/~\s*(\d+[.,]\d+)\s*\$/', $normalizedText, $fiatMatch)) {
+            $fiatValue = (float) str_replace(',', '.', $fiatMatch[1]);
+            if ($fiatValue > 0) {
+                $price = round($fiatValue / $coinsTotal, 8);
+                $flags[] = 'price_derived_from_balance_value';
+                $currency = $currency ?? 'USD';
+            }
+        }
+
+        $measurementIndicators = 0;
+        $normalizedLower = strtolower($normalizedText);
+        foreach (['mining-guthaben', 'mining guthaben', 'mining-balance', 'mining balance', 'doge /', 'bonus', 'verlauf'] as $indicator) {
+            if (str_contains($normalizedLower, $indicator)) {
+                $measurementIndicators++;
+            }
+        }
+
+        $matchedFields = 0;
+        foreach ([$coinsTotal, $price, $currency] as $field) {
+            if ($field !== null) {
+                $matchedFields++;
+            }
+        }
+
+        $score = $matchedFields + min(3, $measurementIndicators);
+        $confidence = max(0.05, min(0.99, ($matchedFields / 3) + (min(3, $measurementIndicators) * 0.08) - (count($flags) * 0.04)));
+
+        return [
+            'suggested' => [
+                'measured_at' => $suggestedTime,
+                'coins_total' => $coinsTotal,
+                'price_per_coin' => $price,
+                'price_currency' => $currency,
+                'note' => null,
+                'source' => 'image_ocr',
+            ],
+            'confidence' => round($confidence, 4),
+            'flags' => $flags,
+            'score' => $score,
+        ];
+    }
+
+    private function parseWalletText(string $rawText, string $dateContext, string $walletCurrencyHint = ''): array
+    {
+        $flags = [];
+        $suggestedTime = null;
+        $totalValueAmount = null;
+        $totalValueCurrency = null;
+        $walletBalance = null;
+        $walletCurrency = $walletCurrencyHint !== '' ? $walletCurrencyHint : 'DOGE';
+        $balances = [];
+
+        $normalizedText = preg_replace('/[[:space:]]+/u', ' ', trim($rawText)) ?: '';
+        $lines = array_values(array_filter(array_map(
+            static fn (string $line): string => trim($line),
+            preg_split('/\R/u', $rawText) ?: []
+        ), static fn (string $line): bool => $line !== ''));
+
+        if (preg_match('/\b([01]?\d|2[0-3]):([0-5]\d)\b/', $normalizedText, $timeMatch)) {
+            $suggestedTime = sprintf('%s %02d:%02d:00', $dateContext, (int) $timeMatch[1], (int) $timeMatch[2]);
+        }
+
+        if (
+            preg_match('/GESAMTSALDO[^\d]{0,24}(\d+(?:[.,]\d+)?)\s*(USD|EUR|USDT|USDC|BTC|ETH|DOGE|CTC|HSH)/i', $normalizedText, $totalMatch)
+            || preg_match('/(\d+(?:[.,]\d+)?)\s*(USD|EUR)\b.*GESAMTSALDO/i', $normalizedText, $totalMatch)
+        ) {
+            $totalValueAmount = round((float) str_replace(',', '.', $totalMatch[1]), 8);
+            $totalValueCurrency = strtoupper((string) $totalMatch[2]);
+        } else {
+            $flags[] = 'wallet_total_missing';
+        }
+
+        $assetRows = [];
+        foreach ($lines as $lineIndex => $line) {
+            if (!preg_match('/(\d+(?:[.,]\d+)?)\s*([A-Z]{2,10})\b/u', $line, $match)) {
+                continue;
+            }
+            $amount = round((float) str_replace(',', '.', $match[1]), 10);
+            $currency = strtoupper((string) $match[2]);
+            if ($amount <= 0 || $currency === '' || in_array($currency, ['USD', 'EUR'], true)) {
+                continue;
+            }
+
+            $assetRows[] = [
+                'index' => $lineIndex,
+                'currency' => $currency,
+                'balance' => $amount,
+            ];
+        }
+
+        foreach ($assetRows as $assetIndex => $assetRow) {
+            $currency = (string) $assetRow['currency'];
+            $balanceAmount = (float) $assetRow['balance'];
+            $startIndex = (int) $assetRow['index'];
+            $endIndex = isset($assetRows[$assetIndex + 1]['index'])
+                ? (int) $assetRows[$assetIndex + 1]['index']
+                : count($lines);
+
+            $usdCandidates = [];
+            for ($i = $startIndex; $i < $endIndex; $i++) {
+                if (!isset($lines[$i])) {
+                    continue;
+                }
+                if (preg_match_all('/(\d+(?:[.,]\d+)?)\s*USD\b/u', $lines[$i], $usdMatches, PREG_SET_ORDER)) {
+                    foreach ($usdMatches as $usdMatch) {
+                        $usdCandidates[] = round((float) str_replace(',', '.', $usdMatch[1]), 8);
+                    }
+                }
+            }
+
+            $priceAmount = $this->pickWalletUnitPrice(
+                $balanceAmount,
+                $usdCandidates,
+                $totalValueCurrency === 'USD' ? $totalValueAmount : null
+            );
+            $balances[$currency] = [
+                'balance' => $balanceAmount,
+                'price_amount' => $priceAmount,
+                'price_currency' => $priceAmount !== null ? 'USD' : null,
+            ];
+        }
+
+        if ($walletCurrencyHint !== '' && array_key_exists($walletCurrencyHint, $balances)) {
+            $walletCurrency = $walletCurrencyHint;
+            $walletBalance = is_array($balances[$walletCurrencyHint])
+                ? (float) ($balances[$walletCurrencyHint]['balance'] ?? 0.0)
+                : (float) $balances[$walletCurrencyHint];
+        } elseif ($balances !== []) {
+            foreach (['DOGE', 'BTC', 'ETH', 'CTC', 'HSH', 'LTC', 'USDT', 'USDC'] as $preferredCurrency) {
+                if (array_key_exists($preferredCurrency, $balances)) {
+                    $walletCurrency = $preferredCurrency;
+                    $walletBalance = is_array($balances[$preferredCurrency])
+                        ? (float) ($balances[$preferredCurrency]['balance'] ?? 0.0)
+                        : (float) $balances[$preferredCurrency];
+                    break;
+                }
+            }
+            if ($walletBalance === null) {
+                $firstCurrency = array_key_first($balances);
+                if (is_string($firstCurrency)) {
+                    $walletCurrency = $firstCurrency;
+                    $walletBalance = is_array($balances[$firstCurrency])
+                        ? (float) ($balances[$firstCurrency]['balance'] ?? 0.0)
+                        : (float) $balances[$firstCurrency];
+                }
+            }
+        } else {
+            $flags[] = 'wallet_balance_missing';
+        }
+
+        $walletIndicators = 0;
+        $normalizedLower = strtolower($normalizedText);
+        foreach (['wallets', 'gesamtsaldo', 'alle münzen', 'alle munzen', 'letzte transaktion'] as $indicator) {
+            if (str_contains($normalizedLower, $indicator)) {
+                $walletIndicators++;
+            }
+        }
+
+        $matchedFields = 0;
+        foreach ([$totalValueAmount, $walletBalance, $walletCurrency] as $field) {
+            if ($field !== null && $field !== '') {
+                $matchedFields++;
+            }
+        }
+        $score = $matchedFields + ($walletIndicators * 2);
+        $confidence = max(0.05, min(0.99, ($matchedFields / 3) + (min(3, $walletIndicators) * 0.12) - (count($flags) * 0.03)));
+
+        ksort($balances);
+
+        return [
+            'suggested_wallet' => [
+                'measured_at' => $suggestedTime,
+                'total_value_amount' => $totalValueAmount,
+                'total_value_currency' => $totalValueCurrency,
+                'wallet_balance' => $walletBalance,
+                'wallet_currency' => $walletCurrency,
+                'balances_json' => $balances,
+                'note' => null,
+                'source' => 'image_ocr',
+            ],
+            'confidence' => round($confidence, 4),
+            'flags' => array_values(array_unique($flags)),
+            'score' => $score,
+        ];
+    }
+
+    /**
+     * @param list<float|int> $candidates
+     */
+    private function pickWalletUnitPrice(float $balance, array $candidates, ?float $walletTotal = null): ?float
+    {
+        $candidates = array_values(array_filter(array_map(
+            static fn (mixed $value): float => round((float) $value, 8),
+            $candidates
+        ), static fn (float $value): bool => $value > 0));
+
+        if ($balance <= 0 || $candidates === []) {
+            return null;
+        }
+        if (count($candidates) === 1) {
+            $candidate = $candidates[0];
+            if ($walletTotal !== null && $walletTotal > 0 && ($balance * $candidate) > ($walletTotal * 1.5)) {
+                return round($candidate / $balance, 8);
+            }
+            return $candidate;
+        }
+
+        $bestPrice = null;
+        $bestError = null;
+        $candidateCount = count($candidates);
+
+        for ($i = 0; $i < $candidateCount; $i++) {
+            $priceCandidate = $candidates[$i];
+            for ($j = 0; $j < $candidateCount; $j++) {
+                if ($i === $j) {
+                    continue;
+                }
+                $totalCandidate = $candidates[$j];
+                $estimatedTotal = $balance * $priceCandidate;
+                $denominator = max(abs($totalCandidate), 0.00000001);
+                $error = abs($estimatedTotal - $totalCandidate) / $denominator;
+                if ($bestError === null || $error < $bestError) {
+                    $bestError = $error;
+                    $bestPrice = $priceCandidate;
+                }
+            }
+        }
+
+        if ($bestPrice !== null && $bestError !== null && $bestError <= 0.2) {
+            return round($bestPrice, 8);
+        }
+
+        return round($candidates[count($candidates) - 1], 8);
+    }
+}

custom/apps/mining-checker/src/Domain/SeedData.php

@@ -0,0 +1,79 @@
+<?php
+declare(strict_types=1);
+
+namespace Modules\MiningChecker\Domain;
+
+final class SeedData
+{
+    public static function projectKey(): string
+    {
+        return 'doge-main';
+    }
+
+    public static function projectName(): string
+    {
+        return 'DOGE Mining Main';
+    }
+
+    public static function settings(): array
+    {
+        return [
+            'baseline_measured_at' => '2026-03-16 01:32:00',
+            'baseline_coins_total' => 27.617864,
+            'daily_cost_amount' => 0.3123287671,
+            'daily_cost_currency' => 'EUR',
+            'preferred_currencies' => ['DOGE', 'USD', 'EUR'],
+        ];
+    }
+
+    public static function currencies(): array
+    {
+        return [
+            ['code' => 'EUR', 'name' => 'Euro', 'symbol' => 'EUR', 'is_active' => 1, 'sort_order' => 10],
+            ['code' => 'USD', 'name' => 'US-Dollar', 'symbol' => 'USD', 'is_active' => 1, 'sort_order' => 20],
+            ['code' => 'DOGE', 'name' => 'Dogecoin', 'symbol' => 'DOGE', 'is_active' => 1, 'sort_order' => 100],
+            ['code' => 'BTC', 'name' => 'Bitcoin', 'symbol' => 'BTC', 'is_active' => 1, 'sort_order' => 110],
+            ['code' => 'ETH', 'name' => 'Ethereum', 'symbol' => 'ETH', 'is_active' => 1, 'sort_order' => 120],
+            ['code' => 'LTC', 'name' => 'Litecoin', 'symbol' => 'LTC', 'is_active' => 1, 'sort_order' => 130],
+            ['code' => 'USDT', 'name' => 'Tether', 'symbol' => 'USDT', 'is_active' => 1, 'sort_order' => 140],
+            ['code' => 'USDC', 'name' => 'USD Coin', 'symbol' => 'USDC', 'is_active' => 1, 'sort_order' => 150],
+        ];
+    }
+
+    public static function measurements(): array
+    {
+        return [
+            ['measured_at' => '2026-03-16 01:32:00', 'coins_total' => 27.617864, 'price_per_coin' => null, 'price_currency' => null, 'note' => 'Basiswert', 'source' => 'seed_import'],
+            ['measured_at' => '2026-03-17 02:41:00', 'coins_total' => 33.751904, 'price_per_coin' => null, 'price_currency' => null, 'note' => 'Kurs wurde spaeter separat genannt, aber nicht sicher exakt diesem Messpunkt zuordenbar', 'source' => 'seed_import'],
+            ['measured_at' => '2026-03-17 07:15:00', 'coins_total' => 34.825695, 'price_per_coin' => 0.10037, 'price_currency' => 'EUR', 'note' => null, 'source' => 'seed_import'],
+            ['measured_at' => '2026-03-17 13:21:00', 'coins_total' => 36.328140, 'price_per_coin' => 0.10002, 'price_currency' => 'EUR', 'note' => null, 'source' => 'seed_import'],
+            ['measured_at' => '2026-03-17 18:53:00', 'coins_total' => 37.682757, 'price_per_coin' => 0.10062, 'price_currency' => 'EUR', 'note' => null, 'source' => 'seed_import'],
+            ['measured_at' => '2026-03-18 00:08:00', 'coins_total' => 38.934351, 'price_per_coin' => 0.10097, 'price_currency' => 'EUR', 'note' => null, 'source' => 'seed_import'],
+            ['measured_at' => '2026-03-18 07:40:00', 'coins_total' => 40.782006, 'price_per_coin' => 0.10040, 'price_currency' => 'EUR', 'note' => null, 'source' => 'seed_import'],
+            ['measured_at' => '2026-03-18 13:32:00', 'coins_total' => 42.223449, 'price_per_coin' => 0.09607, 'price_currency' => 'EUR', 'note' => 'Originaleingabe im Chat: 18.6.2026', 'source' => 'seed_import'],
+            ['measured_at' => '2026-03-18 21:15:00', 'coins_total' => 44.191018, 'price_per_coin' => 0.09446, 'price_currency' => 'EUR', 'note' => null, 'source' => 'seed_import'],
+            ['measured_at' => '2026-03-19 00:09:00', 'coins_total' => 44.908500, 'price_per_coin' => 0.09507, 'price_currency' => 'EUR', 'note' => null, 'source' => 'seed_import'],
+            ['measured_at' => '2026-03-19 02:33:00', 'coins_total' => 45.546924, 'price_per_coin' => 0.09499, 'price_currency' => 'USD', 'note' => 'aus Screenshot extrahiert', 'source' => 'seed_import', 'ocr_flags' => ['source:screenshot']],
+            ['measured_at' => '2026-03-19 07:01:00', 'coins_total' => 46.694127, 'price_per_coin' => 0.09460, 'price_currency' => 'USD', 'note' => 'aus Screenshot extrahiert', 'source' => 'seed_import', 'ocr_flags' => ['source:screenshot']],
+            ['measured_at' => '2026-03-19 12:24:00', 'coins_total' => 48.056494, 'price_per_coin' => 0.09419, 'price_currency' => 'USD', 'note' => 'aus Screenshot extrahiert', 'source' => 'seed_import', 'ocr_flags' => ['source:screenshot']],
+            ['measured_at' => '2026-03-19 21:39:00', 'coins_total' => 50.427943, 'price_per_coin' => 0.09361, 'price_currency' => 'USD', 'note' => 'aus Screenshot extrahiert', 'source' => 'seed_import', 'ocr_flags' => ['source:screenshot']],
+        ];
+    }
+
+    public static function targets(): array
+    {
+        return [
+            ['label' => 'Ziel A', 'target_amount_fiat' => 10.82, 'currency' => 'EUR', 'is_active' => 1, 'sort_order' => 10],
+            ['label' => 'Ziel B', 'target_amount_fiat' => 19.50, 'currency' => 'EUR', 'is_active' => 1, 'sort_order' => 20],
+        ];
+    }
+
+    public static function dashboards(): array
+    {
+        return [
+            ['name' => 'Mining-Verlauf', 'chart_type' => 'line', 'x_field' => 'measured_at', 'y_field' => 'coins_total', 'aggregation' => 'none', 'filters' => [], 'is_active' => 1],
+            ['name' => 'Performance-Verlauf', 'chart_type' => 'area', 'x_field' => 'measured_date', 'y_field' => 'doge_per_day_interval', 'aggregation' => 'avg', 'filters' => [], 'is_active' => 1],
+            ['name' => 'Kurs-Verlauf', 'chart_type' => 'line', 'x_field' => 'measured_at', 'y_field' => 'price_per_coin', 'aggregation' => 'none', 'filters' => [], 'is_active' => 1],
+        ];
+    }
+}

custom/apps/mining-checker/src/Domain/SeedImporter.php

@@ -0,0 +1,62 @@
+<?php
+declare(strict_types=1);
+
+namespace Modules\MiningChecker\Domain;
+
+use Modules\MiningChecker\Infrastructure\MiningRepository;
+
+final class SeedImporter
+{
+    private MiningRepository $repository;
+
+    public function __construct(MiningRepository $repository)
+    {
+        $this->repository = $repository;
+    }
+
+    public function import(string $projectKey): array
+    {
+        $seedProjectKey = SeedData::projectKey();
+        if ($projectKey !== $seedProjectKey) {
+            return ['inserted' => 0, 'project_key' => $projectKey, 'warning' => 'Seed-Daten sind nur fuer doge-main definiert.'];
+        }
+
+        $this->repository->ensureProject($projectKey, SeedData::projectName());
+        $this->repository->saveSettings($projectKey, SeedData::settings());
+
+        $insertedMeasurements = 0;
+        foreach (SeedData::measurements() as $measurement) {
+            try {
+                $this->repository->createMeasurement($projectKey, array_merge([
+                    'image_path' => null,
+                    'ocr_raw_text' => null,
+                    'ocr_confidence' => null,
+                    'ocr_flags' => null,
+                ], $measurement));
+                $insertedMeasurements++;
+            } catch (\Throwable $exception) {
+                // Duplicate seeds are expected on repeated imports.
+            }
+        }
+
+        $targetCount = 0;
+        foreach (SeedData::targets() as $target) {
+            $this->repository->saveTarget($projectKey, $target);
+            $targetCount++;
+        }
+
+        $dashboardCount = 0;
+        foreach (SeedData::dashboards() as $dashboard) {
+            $this->repository->saveDashboard($projectKey, $dashboard);
+            $dashboardCount++;
+        }
+
+        return [
+            'project_key' => $projectKey,
+            'imported_measurements' => $insertedMeasurements,
+            'historical_rows_total' => count(SeedData::measurements()),
+            'targets_synced' => $targetCount,
+            'dashboards_synced' => $dashboardCount,
+        ];
+    }
+}

custom/apps/mining-checker/src/Infrastructure/ConnectionFactory.php

@@ -0,0 +1,57 @@
+<?php
+declare(strict_types=1);
+
+namespace Modules\MiningChecker\Infrastructure;
+
+use App\PdoFactory;
+use Modules\MiningChecker\Support\ApiException;
+use PDO;
+
+final class ConnectionFactory
+{
+    public static function make(ModuleConfig $config): PDO
+    {
+        $moduleSettings = modules()->settings('mining-checker');
+        $useSeparateDb = self::usesSeparateDatabase($moduleSettings);
+
+        if ($useSeparateDb) {
+            $dbConfig = is_array($moduleSettings['db'] ?? null) ? $moduleSettings['db'] : [];
+            if ($dbConfig === []) {
+                throw new ApiException('Custom-Datenbank ist aktiviert, aber nicht vollstaendig konfiguriert.', 500);
+            }
+            self::assertSupportedDriver($dbConfig);
+            return PdoFactory::createFromArray($dbConfig);
+        }
+
+        $dbConfig = app()->config()->dbConfig;
+        if ($dbConfig === []) {
+            throw new ApiException('Projekt-Datenbankkonfiguration fehlt in config/db_settings_basic.php.', 500);
+        }
+
+        self::assertSupportedDriver($dbConfig);
+        return PdoFactory::createFromArray($dbConfig);
+    }
+
+    private static function usesSeparateDatabase(array $moduleSettings): bool
+    {
+        $raw = $moduleSettings['use_separate_db'] ?? false;
+        if (is_bool($raw)) {
+            return $raw;
+        }
+
+        $normalized = strtolower(trim((string) $raw));
+        return in_array($normalized, ['1', 'true', 'yes', 'on', 'custom'], true);
+    }
+
+    private static function assertSupportedDriver(array $dbConfig): void
+    {
+        $driver = strtolower((string) ($dbConfig['driver'] ?? ($dbConfig['dsn'] ?? '')));
+        if ($driver !== '' && !in_array($driver, ['mysql', 'pgsql'], true) && !str_starts_with($driver, 'mysql:') && !str_starts_with($driver, 'pgsql:')) {
+            throw new ApiException(
+                'Mining-Checker unterstuetzt aktuell MySQL/MariaDB und PostgreSQL. Stelle den Driver auf mysql oder pgsql.',
+                500,
+                ['driver' => $dbConfig['driver'] ?? 'unknown']
+            );
+        }
+    }
+}

custom/apps/mining-checker/src/Infrastructure/ModuleConfig.php

@@ -0,0 +1,66 @@
+<?php
+declare(strict_types=1);
+
+namespace Modules\MiningChecker\Infrastructure;
+
+final class ModuleConfig
+{
+    private array $config;
+
+    public function __construct(array $config)
+    {
+        $this->config = $config;
+    }
+
+    public static function load(string $moduleBasePath): self
+    {
+        $config = require $moduleBasePath . '/config/module.php';
+        return new self(is_array($config) ? $config : []);
+    }
+
+    public function defaultProjectKey(): string
+    {
+        return (string) ($this->config['default_project_key'] ?? 'doge-main');
+    }
+
+    public function useProjectDatabase(): bool
+    {
+        return (bool) ($this->config['use_project_database'] ?? true);
+    }
+
+    public function tablePrefix(): string
+    {
+        return (string) ($this->config['table_prefix'] ?? 'miningcheck_');
+    }
+
+    public function uploadsDir(): string
+    {
+        return (string) ($this->config['uploads_dir'] ?? sys_get_temp_dir());
+    }
+
+    public function uploadsPublicPrefix(): string
+    {
+        return rtrim((string) ($this->config['uploads_public_prefix'] ?? '/uploads'), '/');
+    }
+
+    public function ocr(): array
+    {
+        return (array) ($this->config['ocr'] ?? []);
+    }
+
+    public function fx(): array
+    {
+        return (array) ($this->config['fx'] ?? []);
+    }
+
+    public function debug(): array
+    {
+        return (array) ($this->config['debug'] ?? []);
+    }
+
+    public function debugDir(): string
+    {
+        $debug = $this->debug();
+        return (string) ($debug['dir'] ?? (dirname($this->uploadsDir()) . '/debug'));
+    }
+}

custom/apps/mining-checker/src/Legacy/LegacyModuleStore.php

@@ -0,0 +1,191 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\MiningChecker\Legacy;
+
+use RuntimeException;
+
+final class LegacyModuleStore
+{
+    public function __construct(
+        private readonly string $projectRoot,
+        private readonly string $userScope,
+    ) {
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function loadProject(string $projectKey): array
+    {
+        $state = $this->loadAll();
+        $projects = is_array($state['projects'] ?? null) ? $state['projects'] : [];
+
+        if (!isset($projects[$projectKey]) || !is_array($projects[$projectKey])) {
+            $projects[$projectKey] = $this->defaultProjectState($projectKey);
+            $state['projects'] = $projects;
+            $this->saveAll($state);
+        }
+
+        return array_replace_recursive($this->defaultProjectState($projectKey), $projects[$projectKey]);
+    }
+
+    /**
+     * @param array<string, mixed> $projectState
+     */
+    public function saveProject(string $projectKey, array $projectState): void
+    {
+        $state = $this->loadAll();
+        $projects = is_array($state['projects'] ?? null) ? $state['projects'] : [];
+        $projects[$projectKey] = array_replace_recursive($this->defaultProjectState($projectKey), $projectState);
+        $state['projects'] = $projects;
+        $this->saveAll($state);
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function loadAuth(): array
+    {
+        $state = $this->loadAll();
+        $auth = is_array($state['module_auth'] ?? null) ? $state['module_auth'] : [];
+
+        return array_replace_recursive([
+            'required' => true,
+            'users' => [],
+            'groups' => [],
+        ], $auth);
+    }
+
+    /**
+     * @param array<string, mixed> $auth
+     */
+    public function saveAuth(array $auth): void
+    {
+        $state = $this->loadAll();
+        $state['module_auth'] = [
+            'required' => (bool) ($auth['required'] ?? true),
+            'users' => array_values(array_filter(array_map('strval', (array) ($auth['users'] ?? [])))),
+            'groups' => array_values(array_filter(array_map('strval', (array) ($auth['groups'] ?? [])))),
+        ];
+        $this->saveAll($state);
+    }
+
+    public function nextId(string $projectKey, string $bucket): int
+    {
+        $project = $this->loadProject($projectKey);
+        $counters = is_array($project['_counters'] ?? null) ? $project['_counters'] : [];
+        $next = (int) ($counters[$bucket] ?? 0) + 1;
+        $counters[$bucket] = $next;
+        $project['_counters'] = $counters;
+        $this->saveProject($projectKey, $project);
+
+        return $next;
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function loadAll(): array
+    {
+        $path = $this->path();
+
+        if (!is_file($path)) {
+            return [
+                'module_auth' => [
+                    'required' => true,
+                    'users' => [],
+                    'groups' => [],
+                ],
+                'projects' => [],
+            ];
+        }
+
+        $raw = file_get_contents($path);
+        if ($raw === false || trim($raw) === '') {
+            return [
+                'module_auth' => [
+                    'required' => true,
+                    'users' => [],
+                    'groups' => [],
+                ],
+                'projects' => [],
+            ];
+        }
+
+        $data = json_decode($raw, true);
+
+        return is_array($data) ? $data : [
+            'module_auth' => [
+                'required' => true,
+                'users' => [],
+                'groups' => [],
+            ],
+            'projects' => [],
+        ];
+    }
+
+    /**
+     * @param array<string, mixed> $state
+     */
+    private function saveAll(array $state): void
+    {
+        $directory = dirname($this->path());
+        if (!is_dir($directory) && !mkdir($directory, 0775, true) && !is_dir($directory)) {
+            throw new RuntimeException('Mining-Checker Speicherverzeichnis konnte nicht erstellt werden.');
+        }
+
+        $json = json_encode($state, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
+        if ($json === false) {
+            throw new RuntimeException('Mining-Checker Speicherinhalt konnte nicht serialisiert werden.');
+        }
+
+        if (file_put_contents($this->path(), $json . PHP_EOL, LOCK_EX) === false) {
+            throw new RuntimeException('Mining-Checker Speicherinhalt konnte nicht geschrieben werden.');
+        }
+    }
+
+    private function path(): string
+    {
+        $safeScope = preg_replace('/[^a-zA-Z0-9_-]+/', '-', $this->userScope) ?: 'guest';
+
+        return $this->projectRoot . '/data/mining-checker/users/' . $safeScope . '.json';
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function defaultProjectState(string $projectKey): array
+    {
+        return [
+            '_counters' => [],
+            'project' => [
+                'project_key' => $projectKey,
+                'project_name' => strtoupper(str_replace('-', ' ', $projectKey)),
+            ],
+            'settings' => [
+                'baseline_measured_at' => gmdate('Y-m-d H:i:s'),
+                'baseline_coins_total' => 0,
+                'daily_cost_amount' => 0,
+                'daily_cost_currency' => 'EUR',
+                'report_currency' => 'EUR',
+                'crypto_currency' => 'DOGE',
+                'display_timezone' => 'Europe/Berlin',
+                'fx_max_age_hours' => 3,
+                'module_theme_mode' => 'inherit',
+                'module_theme_accent' => 'teal',
+                'preferred_currencies' => ['DOGE', 'USD', 'EUR'],
+            ],
+            'measurements' => [],
+            'targets' => [],
+            'dashboards' => [],
+            'wallet_snapshots' => [],
+            'cost_plans' => [],
+            'payouts' => [],
+            'miner_offers' => [],
+            'purchased_miners' => [],
+            'fx_history' => [],
+        ];
+    }
+}

custom/apps/mining-checker/src/Legacy/UserScope.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\MiningChecker\Legacy;
+
+use ModulesCore\ModuleHttp;
+
+final class UserScope
+{
+    public static function current(): string
+    {
+        return ModuleHttp::currentUserScope();
+    }
+}

custom/apps/mining-checker/src/Support/ApiException.php

@@ -0,0 +1,29 @@
+<?php
+declare(strict_types=1);
+
+namespace Modules\MiningChecker\Support;
+
+use RuntimeException;
+
+final class ApiException extends RuntimeException
+{
+    private int $statusCode;
+    private array $context;
+
+    public function __construct(string $message, int $statusCode = 400, array $context = [])
+    {
+        parent::__construct($message);
+        $this->statusCode = $statusCode;
+        $this->context = $context;
+    }
+
+    public function statusCode(): int
+    {
+        return $this->statusCode;
+    }
+
+    public function context(): array
+    {
+        return $this->context;
+    }
+}

custom/apps/mining-checker/src/Support/DebugState.php

@@ -0,0 +1,35 @@
+<?php
+declare(strict_types=1);
+
+namespace Modules\MiningChecker\Support;
+
+final class DebugState
+{
+    private static array $trace = [];
+    private static ?string $latestFilePath = null;
+
+    public static function replace(array $trace): void
+    {
+        self::$trace = $trace;
+    }
+
+    public static function export(): array
+    {
+        return self::$trace;
+    }
+
+    public static function clear(): void
+    {
+        self::$trace = [];
+    }
+
+    public static function setLatestFilePath(?string $filePath): void
+    {
+        self::$latestFilePath = $filePath;
+    }
+
+    public static function latestFilePath(): ?string
+    {
+        return self::$latestFilePath;
+    }
+}

custom/apps/mining-checker/src/Support/DebugTrace.php

@@ -0,0 +1,60 @@
+<?php
+declare(strict_types=1);
+
+namespace Modules\MiningChecker\Support;
+
+final class DebugTrace
+{
+    private bool $enabled;
+    private array $entries = [];
+    private ?string $filePath;
+
+    public function __construct(bool $enabled = false, ?string $filePath = null)
+    {
+        $this->enabled = $enabled;
+        $this->filePath = $enabled ? $filePath : null;
+        DebugState::replace([]);
+        if ($this->enabled && $this->filePath !== null) {
+            $this->persist();
+        }
+    }
+
+    public function enabled(): bool
+    {
+        return $this->enabled;
+    }
+
+    public function add(string $event, array $context = []): void
+    {
+        if (!$this->enabled) {
+            return;
+        }
+
+        $this->entries[] = [
+            'time' => date('c'),
+            'event' => $event,
+            'context' => $context,
+        ];
+        DebugState::replace($this->entries);
+        $this->persist();
+    }
+
+    public function export(): array
+    {
+        return $this->enabled ? $this->entries : [];
+    }
+
+    private function persist(): void
+    {
+        if (!$this->enabled || $this->filePath === null) {
+            return;
+        }
+
+        $directory = dirname($this->filePath);
+        if (!is_dir($directory)) {
+            @mkdir($directory, 0775, true);
+        }
+
+        @file_put_contents($this->filePath, json_encode($this->entries, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
+    }
+}

custom/apps/mining-checker/src/Support/Http.php

@@ -0,0 +1,27 @@
+<?php
+declare(strict_types=1);
+
+namespace Modules\MiningChecker\Support;
+
+final class Http
+{
+    public static function json(array $payload, int $statusCode = 200): never
+    {
+        http_response_code($statusCode);
+        header('Content-Type: application/json; charset=utf-8');
+        echo json_encode($payload, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
+        exit;
+    }
+
+    public static function input(): array
+    {
+        $contentType = $_SERVER['CONTENT_TYPE'] ?? '';
+        if (str_contains($contentType, 'application/json')) {
+            $raw = file_get_contents('php://input');
+            $data = json_decode($raw ?: '[]', true);
+            return is_array($data) ? $data : [];
+        }
+
+        return $_POST;
+    }
+}