🔒 Privacy Policy

📋1. Introduction

Sudoku Battle ("the Application") is developed by TheCatsizerLab and available on Google Play Store. We respect your privacy and are committed to processing your personal data transparently and securely in accordance with GDPR and applicable data protection laws worldwide.

This privacy policy explains how we collect, use, share, and protect your personal data when you use our Application.

1.1 Historical Note — Identification System Evolution

Prior to July 2, 2026, the Application relied solely on a device-based identifier (derived from your device's Android ID) for all players, alongside an earlier, now-discontinued, optional integration with Google Play Games Services (GPGS). The GPGS SDK was fully removed from the Application on July 2, 2026, and no data is sent to or received from Google Play Games Services.

As of July 11, 2026, the Application introduced a new identification choice screen shown once, on first launch (or until a choice is made). Players can choose to:

• Sign in with a Google Account — using native Google Sign-In (the google_sign_in Flutter package), separate from and unrelated to the previously removed Google Play Games Services; or
• Continue as a guest — using a randomly generated identifier stored only on your device, with no connection to your device hardware.

Players who already had an account before this update (whether from the device-based system or the discontinued GPGS integration) are automatically and transparently migrated to their existing identifier if they choose "Continue as a guest," preserving their existing server-side statistics (scores, progression, achievements) without any action required on their part. This choice screen is shown only once; it does not reappear once a choice has been made.

Any section of this policy that previously described GPGS-specific data collection (Player ID, display name, profile picture, cloud saves, GPGS leaderboards, GPGS achievements) no longer applies. Where relevant, we have retained a short historical note rather than removing all references, for transparency about what was previously collected.

👤2. Data Controller

2.2 App Package Information

• App Package Name: com.catsizerlab.sudoku
• Google Play Store Link: View on Google Play
• Minimum Android Version: Android 7.0 (API 24)
• Target Android Version: Android 14/15 (API 34/35)

📊3. Data We Collect

3.1 Data Collected Directly from You

🔀Identification Choice (First Launch)

On first launch of the Application (or until you make a choice), you are presented with a screen asking you to choose between two identification methods. This choice is required to continue using the Application, but the specific method you pick is entirely your decision.

Legal Basis: Consent (Article 6.1.a) for the choice itself, Contract (Article 6.1.b) for the resulting identification | Purpose: Enable account identification, progression saving, leaderboards, and multiplayer features

Frequency: This screen is shown once. Once a choice is made, it is remembered locally and the screen does not reappear, regardless of which option was chosen.

🔑Google Sign-In

If you choose to sign in with Google, the Application uses the official google_sign_in Flutter package to authenticate you through your device's Google account.

• Data requested from Google: your email address and Google account identifier only (scope: email) — no extended profile data, no contacts, no other Google service data
• Your Google password is never accessed, seen, or stored by us — authentication is handled entirely by Google's sign-in flow
• Google issues a short-lived ID token, which is sent to our game server and verified server-side using Google's official google-auth-library before your account is created or matched
• Your resulting player identifier is derived from your verified Google account identifier (not your email address directly)

Legal Basis: Consent (Article 6.1.a) + Service contract (Article 6.1.b) | Purpose: Secure, persistent account identification across devices and reinstalls

Storage: Verified account identifier and associated game data stored on our own servers (Fly.io / Neon PostgreSQL); the Google ID token itself is not stored after verification

🆔Guest Identifier (Randomly Generated)

• If you choose "Continue as a guest," a random identifier (not derived from your device hardware, Android ID, or any personal data) is generated using a cryptographically secure random generator
• This identifier is used as your player identifier for all game features (progression, leaderboards, multiplayer, daily challenges, friends)
• It is not linked to your real identity, name, email, or any external account
• If you already had an existing account on this device before this identification system was introduced, that existing identifier is reused automatically — no new identifier is created and no progress is lost

Legal Basis: Service contract (Article 6.1.b) | Purpose: Enable core game features for players who do not wish to sign in with Google

Storage: Device local storage (SharedPreferences) + server-side (Fly.io / Neon PostgreSQL)

Retention: As long as needed to provide the service and maintain integrity of features, subject to security and legal requirements

As part of migrating existing players to this system, a device identifier previously derived from your Android device (used prior to July 11, 2026, see "Legacy Device Identifier" below) may still be read once, locally, purely to detect and preserve an existing account during migration. It is not used to create new identifiers going forward.

📱Legacy Device Identifier (Migration Only)

• Used only for reading/matching an existing pre-July 2026 account during the one-time migration described above
• Never used to generate a new identifier for players who did not already have one
• The raw Android ID itself is never transmitted to our servers — only a one-way SHA-256 hash derived from it

Legal Basis: Service contract (Article 6.1.b) — necessary to preserve existing players' progress during the migration | Purpose: Prevent data loss for existing players

🎮Player Identification — General

• Your resulting player identifier (from Google Sign-In or guest identifier, as described above)
• A display name you choose or that is assigned by default
• Game progression data stored on our own servers (Fly.io / Neon PostgreSQL)

Legal Basis: Service contract | Purpose: Authentication, server-side sync, leaderboards, achievements

🎯Game Data

• Game scores (solo and multiplayer)
• Match history (duration, error count, game mode)
• Progression through levels
• Selected difficulty
• Elapsed time in games
• Number of correct placements
• Combo statistics

Legal Basis: Service contract | Purpose: Save progression, populate leaderboards, improve gameplay

👥Multiplayer Data

• Opponent's display name
• Real-time game progression
• Match statistics (correct moves, errors, combo)
• Match results
• Energy and power-ups used
• Friends list and friend codes
• Pending friend invitations

Legal Basis: Service contract | Purpose: Real-time multiplayer sync, leaderboards, game balancing

💾Match Details Backup (Local)

• Last 5 matches stored in device SharedPreferences
• Includes: opponent name, scores, victory/defeat, reason, timestamp

Purpose: Display recent match history offline

Retention: Until manual app data clear

Storage: SharedPreferences (JSON format)

⏱️Deferred Game Results (Backup System)

Purpose: Prevent lost match results due to disconnects during game_over event

Storage:

• PostgreSQL database (Neon) - table: finished_games
• Columns stored:
  • room_id (UNIQUE) - Match identifier
  • winner_id, winner_name, winner_score
  • loser_id, loser_name, loser_score
  • reason (completed, abandoned, timeout, too_many_errors)
  • winner_delivered (BOOLEAN) - Has winner retrieved result?
  • loser_delivered (BOOLEAN) - Has loser retrieved result?
  • created_at (TIMESTAMP)

Dual-Flag Delivery System:

1. When a player is offline at match end, result is stored with their delivery flag = FALSE
2. When player reconnects and retrieves result via GET /api/game_over/check/{playerId}, their flag becomes TRUE
3. Row is ONLY deleted when BOTH winner_delivered AND loser_delivered are TRUE
4. This ensures both players receive their match result exactly once

API Endpoints:

• POST /api/game_over/batch - Store results for multiple disconnected players (atomic batch insert)
• GET /api/game_over/check/{playerId} - Atomic retrieval sequence:
  • SELECT FOR UPDATE SKIP LOCKED (prevents race conditions)
  • UPDATE delivery flag for requesting player (winner_delivered or loser_delivered)
  • DELETE row if both flags are TRUE
  • Returns match result in single transaction

Retention:

• Until both players retrieve result (automatic deletion after dual-confirmation)
• Auto-cleanup: Results older than 1 hour are deleted (even if not retrieved)
• Cleanup runs every hour via scheduled job

Privacy:

• Stored in encrypted PostgreSQL (Neon) with SSL/TLS connections
• No persistent retention after both players confirm delivery
• Maximum retention: 1 hour (hard limit via cleanup job)

Security:

• Atomic database operations prevent duplicate delivery
• SKIP LOCKED prevents concurrent retrieval conflicts
• Transaction rollback on any error ensures data consistency

⚙️Preference Data

• Selected visual theme
• Language preference
• Audio settings (sound enabled/disabled)
• Vibration preferences
• Premium theme purchase history

Storage: Device local storage (SharedPreferences)

Legal Basis: Service contract | Purpose: Personalize user experience

🔊Audio Preferences

• Sound enabled/disabled state
• Music volume level (0.0-1.0)
• Sound effects volume level (0.0-1.0)
• Last played music track

Storage: Device local storage (SharedPreferences)

Legal Basis: Service contract

Purpose: Remember your audio settings across sessions

☁️Cloud Game Save (Historical — GPGS, discontinued)

🏅Achievement Progress Tracking (Local)

• Win counters (per difficulty + total)
• Flawless games count (0 errors)
• Hints usage statistics
• Notes usage frequency
• Correct placement accuracy
• Win streak counters (current + best)
• Error-free grids completed
• Daily challenge participation streak
• Multiplayer victories

Storage: Device local storage (SharedPreferences)

Legal Basis: Service contract

Purpose: Track achievement unlock progress

Sync: Synced with our own servers when achievements are unlocked

Retention: As long as app is installed

📊Player Profile Statistics

• Total games played (solo + multiplayer)
• Games won/lost (per game mode)
• Win rate percentage (automatically calculated)
• Last game timestamp
• Profile creation date

Legal Basis: Service contract

Purpose: Display player performance statistics

Visibility: Private (only visible to you)

Retention: As long as needed to provide the service and maintain integrity of features, subject to security and legal requirements.

💾Profile Statistics Storage (PostgreSQL)

Storage Structure:

• Solo Statistics Table (player_profile_solo):
  • games_played (INTEGER)
  • games_won (INTEGER)
  • games_lost (INTEGER)
  • last_game_at (TIMESTAMP - last solo match completed)
  • created_at / updated_at (TIMESTAMP)
• Multiplayer Statistics Table (player_profile_multi):
  • games_played (INTEGER)
  • games_won (INTEGER)
  • games_lost (INTEGER)
  • last_game_at (TIMESTAMP - last multiplayer match completed)
  • created_at / updated_at (TIMESTAMP)

Calculation:

• Win rate: (games_won / games_played) × 100
• Calculated server-side on each API request

API Endpoints:

• GET /api/profile/stats?gameMode=solo - Retrieve solo statistics
• GET /api/profile/stats?gameMode=multi - Retrieve multiplayer statistics
• POST /api/profile/update - Updates statistics after each match completion

Storage Location: PostgreSQL (Neon) - encrypted at rest (AES-256)

Retention: As long as needed to provide the service and maintain integrity of features, subject to security and legal requirements.

Privacy: Statistics are private and only visible to the account owner

📊Profile Statistics Cache (In-Memory)

• Solo/Multi stats cached in RAM (not persistent storage)
• Auto-refresh from server on app resume
• Cached data: gamesPlayed, gamesWon, gamesLost, winrate, lastGameAt, updatedAt

Purpose: Reduce API calls, improve performance

Storage: Volatile memory (lost on app close)

Retention: Session only (cleared when app is closed)

3.2 Data Collected Automatically

🖥️Technical Data

• Device type and model
• Android OS version
• Unique identifiers (Android Advertising ID)
• IP address
• Region and timezone
• Storage capacity and remaining storage
• Device memory information

Legal Basis: Legitimate interest (technical maintenance, security, analytics) | Purpose: Performance optimization, fraud prevention, debugging

📱Connection Data

• Session timestamps
• Session duration
• Game events (matches started, completed, abandoned)
• Ad interaction data (impressions, clicks, rewarded ad views)
• Connection type (WiFi vs cellular)
• App launch frequency

Legal Basis: Legitimate interest (service improvement and performance monitoring) | Purpose: Service improvement, usage analysis, performance monitoring

⚠️Crash and Error Data (Firebase Crashlytics)

Automatic Collection: Firebase Crashlytics automatically captures and sends crash reports when the app crashes.

• Crash reports: Automatic fatal error reports with stack traces
• Non-fatal errors: Logged exceptions (manually recorded by developers)
• Stack traces: Full error trace for debugging
• Application state: Memory usage, device orientation, free disk space at crash time
• Device information: Model, OS version, manufacturer
• Session data: App version, crash timestamp, time since app launch
• Custom logs: Developer-added breadcrumbs for debugging context

Data NOT collected by Crashlytics:

• ❌ User identifiers (Player ID) - NOT automatically linked
• ❌ IP addresses
• ❌ Personal data from game state (grid content, scores)

Storage & Retention:

• Storage: Firebase services operated by Google.
• Retention: Crash reports are retained according to Google's Firebase retention policies and settings. We do not implement custom server-side deletion for Crashlytics data.
• Security: Data is encrypted in transit (TLS) and handled under Google's security controls.

Legal Basis: Legitimate interest (GDPR Article 6.1.f - technical maintenance, security, app stability)

Purpose: Detect and fix crashes, improve app stability, prevent future errors

🔐Android Permissions

The Application requests the following Android permissions:

Note: All permissions are requested at runtime and can be revoked in Android Settings > Apps > Sudoku Battle > Permissions.

3.3 Payment Data

💳In-App Purchase Transactions

• Products purchased (premium lifetime, theme bundle, individual themes)
• Purchase tokens (Google Play verification data)
• Purchase amount and currency
• Transaction date and time
• Transaction status (completed, pending, failed, restored)
• Product IDs (premium_lifetime, theme_spring_premium, theme_tropical_premium, theme_midnight_premium, theme_rainy_premium, theme_desert_premium, theme_golden_premium, theme_cherry_premium, theme_sky_premium, theme_rice_premium, theme_bundle_premium)

Legal Basis: Service contract | Purpose: Purchase management, product attribution, fraud prevention

🔄Purchase Restoration

• Purchase restoration requests (timestamp)
• Server-side purchase validation (Google Play receipt verification)
• Backup purchase records (in case of Google Play sync failure)
• Restoration attempts (frequency, device changes)

Purpose: Ensure purchases are not lost on device change/reinstall

Security: Dual validation (Google Play + server-side)

3.4 Third-Party Data

📢Google AdMob (Advertising)

Advertisements displayed in the Application are managed by Google through AdMob.

Data collected by Google:

• Android Advertising ID
• Inferred interest categories
• Ad view history
• Ad clicks
• App usage patterns

Regional Notice: In certain regions (such as the EEA, UK, and Switzerland), Google may require a consent message for personalized ads. When required, consent is handled according to Google's requirements and supported consent solutions.

Legal Basis: Consent (compliant with Google policy) | Purpose: Personalized ad delivery, app monetization

Manage Ad Preferences: Go to Settings > Google > Manage your Google Account > Data & Privacy > Ad Settings

🔥Firebase Services (Google)

Firebase Analytics

• Automatic screen view tracking
• Session duration and frequency
• Device type, OS version, app version
• Custom events logged by developers (game_start, game_end, purchase, etc.)

Provider: Google LLC

Privacy Policy: firebase.google.com/support/privacy

Firebase Crashlytics

• Crash reports (fatal errors only)
• Stack traces for debugging
• Device state at crash time (memory, storage, battery)
• NO personal data (Player ID, game scores) unless manually logged

Provider: Google LLC

Privacy Policy: firebase.google.com/support/privacy/crashlytics

Legal Basis: Legitimate interest (GDPR Article 6.1.f)

Retention: Retention periods are controlled by Google's Firebase policies and configuration. We do not implement custom deletion routines for Firebase Analytics or Crashlytics data.

⚡Power-Up Cooldown & Energy Management

Cooldown System:

• 5 seconds minimum between power-up activations
• Last activation timestamp stored in RAM (player.lastPowerUpTime)
• Throttle protection: 100ms minimum between trigger_power events (spam prevention)

Energy Deduction:

• Energy cost: 1 point per power-up activation
• Deducted BEFORE power-up validation (prevents race conditions)
• Automatic refund if power-up fails execution

Refund Scenarios (Energy returned to player):

• Opponent disconnected at activation time
• No valid cells to erase (cell_eraser power-up on empty grid)
• Self-target on invalid grid state
• Invalid game state (match already finished)
• Power-up activation during cooldown period

Power-Up Targeting:

• 80% chance: Targets opponent
• 20% chance: Targets yourself (random server-side selection)
• Randomization performed server-side for fairness

Storage: RAM only (session-based, not persistent)

Purpose: Prevent power-up spam, ensure fair energy consumption, maintain game balance

Retention: Until match ends or player disconnects (volatile memory)

🎬Rewarded Video Ads

• Ad impression timestamps
• Ad completion status (watched fully vs skipped)
• Rewards earned (continue game, bonus hints)
• Ad unit IDs shown
• Frequency capping data

Legal Basis: Consent (Google ToS)

Purpose: Provide optional rewards in exchange for ad views

Provider: Google AdMob

Control: You can refuse to watch ads (feature unavailable without viewing)

⏱️Rewarded Ad Cooldown

• Last ad view timestamp stored locally
• Minimum 3 minutes cooldown between rewarded ads

Purpose: Prevent ad spam exploitation

Control: Premium subscription removes ads entirely

⏱️Interstitial Ad Frequency Control

• Last ad display timestamp (stored locally)
• Games played since last ad (counter)
• Cooldown timer (3 minutes minimum between ads)
• Ad display frequency (1 ad per 3 games completed)

Storage: Device local storage (SharedPreferences)

Purpose: Limit ad annoyance, respect user experience

Control: Premium subscription removes all interstitial ads

🏆Leaderboards & Achievements (formerly Google Play Games Services)

• Public scores on leaderboards
• Unlocked achievement badges
• Public display name

Legal Basis: Service contract | Purpose: Leaderboards, social features

📊Private Statistics Leaderboards (Historical — GPGS, discontinued)

3.5 Daily Challenge Data

📅Daily Puzzle Progress

• Daily puzzle completion status (completed date stored locally)
• Best daily scores per challenge date
• Completion times (in seconds)
• Number of hints used per challenge (0-2)
• Submission timestamps

Legal Basis: Service contract | Purpose: Daily challenge leaderboards, player engagement tracking

Storage: PostgreSQL database (Neon) via Fly.io servers (USA)

Retention: Indefinite (for leaderboard integrity and historical rankings)

🏆Daily Leaderboards

• Public rankings (today + all-time)
• Player names associated with scores
• Total days participated
• Average completion times

Visibility: All daily challenge scores are publicly visible in leaderboards

🔒Duplicate Submission Prevention

Server-Side Validation:

• Before accepting a score, server checks if player already completed today's challenge
• SQL query: SELECT COUNT(*) WHERE player_id = $1 AND challenge_date = $2
• HTTP 409 Conflict error returned if already completed
• Prevents score manipulation and duplicate submissions

Client-Side Check:

• GET /api/daily/check-completed - Returns boolean completion status
• Called on app launch to disable "Play" button if already completed
• Local cache updated after successful submission

Purpose: Ensure fair leaderboards, prevent score manipulation, maintain competitive integrity

Legal Basis: Legitimate interest (fraud prevention - GDPR Article 6.1.f)

📊Anti-Cheat Validation

• Maximum score limit: 9500 points (server-side enforcement)
• Time validation: Must be positive integer (in seconds)
• Hints validation: 0-2 hints only (expert difficulty allows max 2 hints)
• Scores exceeding limits are rejected with HTTP 400 Bad Request
• Suspicious submissions flagged for review (see Section 6.1)

3.6 Friends System Data

👥Friend Connections

• Unique friend code (8-digit numeric format: XXXX-XXXX, e.g., 1234-5678)
• Friend code validation (must match format ^\d{4}-\d{4}$)
• Friend list (player IDs + display names)
• Friend invitations sent/received (status: pending, accepted, declined)
• Friendship timestamps (creation date)
• Last synchronization time

Legal Basis: Consent + Service contract | Purpose: Social features, friend-to-friend matching

🔐Friend Code Generation

Your friend code is generated using a deterministic, non-reversible hash algorithm based on your player identifier. This means:

• The code cannot be traced back to your player identifier
• It remains the same across all your sessions
• No personally identifiable information is embedded in the code

⚡Friend Invitations

• Sender information (Player ID, name, friend code)
• Recipient friend code (8-digit code)
• Invitation status (pending, accepted, declined)
• Game mode and difficulty requested (if challenge)

Retention: 60 seconds (auto-expire if not responded), then permanently deleted

Storage: PostgreSQL database (Neon) via Fly.io servers (USA)

3.7 Challenge System Data

⚔️Player-to-Player Challenges

• Challenge sender/receiver information (Player ID, name)
• Game mode requested (classic, powerup, timeAttack)
• Difficulty level requested (easy, medium, hard, expert)
• Challenge acceptance/decline status
• Challenge timestamps (sent, responded)

Legal Basis: Service contract | Purpose: Facilitate direct player-to-player matches

Retention: 60 seconds maximum (auto-expire), then permanently deleted

Storage: Temporary in-memory storage (server RAM), no persistent database storage

3.8 Authentication Tokens

🔑JWT Authentication

• JWT tokens (JSON Web Tokens) containing:
  • Player ID — your Google Sign-In-derived or guest identifier (encrypted)
  • Player Name (encrypted)
  • Expiration timestamp (30 days)
• Token generation timestamp
• Token stored locally (SharedPreferences - encrypted)

Legal Basis: Service contract + Security (legitimate interest)

Purpose: Secure API authentication for leaderboards, daily challenges, friends system

Expiration: 30 days (automatic renewal on reconnection)

Storage Location: Device local storage (encrypted) + server-side validation

Security: Tokens are signed using industry-standard HS256 algorithm with a 32+ character secret key

3.9 Real-Time Multiplayer Data (WebSocket/Socket.IO)

🌐WebSocket Connection

During multiplayer matches, your device establishes a real-time WebSocket connection to our game server.

Timestamp Synchronization:

• startTime: Match creation timestamp (UTC) - used to calculate elapsed time
• serverTime: Current server timestamp (UTC) - sent on matchFound to sync client clock
• Usage: Calculate elapsedSeconds = (currentTime - startTime) / 1000
• Time Attack: Sync personalEndTime countdown timers across devices
• Privacy Note: Timestamps are in UTC (no timezone data sent), but difference between server and client time may indirectly reveal timezone

Time Attack - Time Consumed:

• Calculated when match ends or timer expires: timeConsumed = (timeLimit - timeRemaining) / 1000
• Stored temporarily in player object (RAM) during match
• Sent in game_over event to both players
• Purpose: Display actual time taken to complete puzzle (performance tracking)
• Storage: Not persisted to database (session-only data)

Server: sudokupuzzle-server.fly.dev (Fly.io infrastructure, USA)

Transport Security: WebSocket Secure (WSS) over TLS 1.3

Legal Basis: Service contract (multiplayer functionality)

Purpose: Enable real-time 1v1 synchronization

🔄Reconnection Dialog

When you reconnect after temporary disconnect (within 60 seconds), server sends:

• Current grid state (your puzzle with filled cells)
• Initial puzzle (frozen state at match start)
• Solution grid (complete puzzle reference)
• Opponent progress (percentage completion 0-81)
• Your stats:
  • correctMoves (validated placements)
  • errors (incorrect placements)
  • combo (current streak)
  • energy (power-up charges available)
  • energyCombo (progress toward next energy point)
  • currentScore (recalculated at reconnection)
  • drainRate (Classic/PowerUp only)
• Elapsed time since match start (in seconds): elapsedSeconds = Math.floor((Date.now() - room.startTime) / 1000)
• personalEndTime (Time Attack only - your timer deadline in Unix timestamp ms)
• startTime (match creation timestamp - used to recalculate elapsed time client-side)

Score Recalculation on Reconnection:

• Classic/PowerUp: score = initialPool - (elapsedSeconds × drainRate) + (correctMoves × basePoints) - (errors × errorPenalty)
• Time Attack: score = currentScore (accumulated points, no recalculation needed)
• Ensures fair scoring even after disconnect/reconnect

Data Source: All data retrieved from server RAM (rooms object), no database queries

Retention: Sent once on reconnection, not stored client-side beyond session

3.10 Backend Server Infrastructure

🏆Leaderboard Backend Server

• Server URL: sudokupuzzle-leaderboards.fly.dev
• Location: Fly.io infrastructure (USA)
• Purpose: Store and rank player scores globally
• Data stored:
  • Player ID (Google Sign-In or guest identifier)
  • Player Name
  • Total scores per category (solo/multi/daily)
  • Games played count
  • Last submission timestamp
• Security: JWT authentication (Bearer tokens)
• Retention: 90 days inactivity-based cleanup

💾PostgreSQL Database (Neon)

• Purpose: Persistent storage for daily challenges, friends, leaderboards
• Location: Neon infrastructure (USA)
• Data stored:
  • Daily challenge scores and completion times
  • Friend codes and friendships
  • Friend invitations (60s expiry)
  • Player statistics
• Security: Encrypted at rest (AES-256)
• Access: API requests only (no direct database access)

🎯4. How We Use Your Data

4.1 Primary Purposes

🔄Data Merge Strategy (Historical — GPGS cloud sync, discontinued)

4.2 Data Sharing

Your data is NEVER sold to third parties.

⏳5. Data Retention

We retain data only for as long as necessary to provide the Application, maintain competitive integrity (such as leaderboards), prevent abuse, and comply with legal obligations.

5.1 Local Device Data

Some preferences and gameplay-related data may be stored locally on your device (e.g., settings, cached data, recent matches). This data remains on your device until you clear the app data or uninstall the Application.

5.2 Server Data (Game Features)

Where server-side features are provided (such as multiplayer, friends, and leaderboards), related records may be retained as long as needed for the operation and integrity of these features and for security/fraud prevention.

5.3 Third-Party Services (Google)

Some data is processed by third-party services such as Google Sign-In, Google AdMob and Firebase (Analytics/Crash reporting). Retention for those services is governed by their policies and configuration. We do not implement custom deletion routines for data stored and retained by these third-party services.

5.4 Legal and Accounting

Where required by law (for example, for accounting, taxation, or fraud prevention), certain transaction-related records may be retained for the legally required period.

🔐6. Data Security

6.1 Technical Measures

• Encryption in Transit: HTTPS/TLS 1.3 for all transfers
• Encryption at Rest: Server data encrypted via PostgreSQL (AES-256)
• Server Isolation: Fly.io infrastructure with network isolation
• No Payment Storage: Payment data remains with Google (never stored locally)
• Google Sign-In Verification: ID tokens are verified server-side against Google's public keys before any account is created or matched; your Google password is never transmitted to or seen by us
• Input Validation: Protection against SQL injection, XSS attacks
• JWT Authentication: Secure tokens with 30-day expiration, HS256 signature algorithm
• PostgreSQL Encryption: Data encrypted at rest via Neon infrastructure (AES-256)
• Friend Code Hashing: Non-reversible deterministic hashing (cannot be traced back to your identifier)
• Challenge Data Volatility: Challenges stored in RAM only (60s max), never written to disk
• Purchase Token Validation: Tokens sent to server over HTTPS/TLS 1.3, validated once, then discarded
• Request Timeouts: 15 seconds maximum per API request (prevents hanging)
• Cold Start Handling: Extended timeout (12s) on server wake-up (Fly.io sleep mode)

🔄WebSocket Connection Retry Logic

• Connection Timeout: 30 seconds maximum (60 attempts × 500ms intervals)
• Retry Mechanism: Automatic retry every 500ms until connected or timeout
• Reconnection Window: 60 seconds grace period after disconnect before match abandonment

Purpose: Handle temporary network interruptions, prevent match loss due to brief disconnects

🛡️Rate Limiting

Protection Levels:

• General API: 100 requests/minute per IP address
• Score Submission: 50 requests/minute per IP address
• Friend System: 30 requests/minute per IP address
• Auth Endpoints: 5 requests/minute per IP address (failed attempts counted)

Data Collected for Rate Limiting:

• IP address (temporary tracking for rate limit enforcement only)
• Request counters per IP (rolling window)
• Timestamp of first request in current window

Implementation:

• Express-rate-limit middleware (server-side)
• Rolling window algorithm (resets every 60 seconds)
• HTTP 429 "Too Many Requests" response when limit exceeded

Retention: 60 seconds (rolling window), then automatically cleared

Purpose: Prevent API abuse, DDoS attacks, score manipulation via spam

Legal Basis: Legitimate interest (security - GDPR Article 6.1.f)

🚨Anti-Cheat - Suspicious Score Flagging

Detection Criteria:

• Scores exceeding maximum thresholds:
  • Solo Easy: > 5000 points
  • Solo Medium: > 8000 points
  • Solo Hard: > 10000 points
  • Solo Expert: > 15000 points
  • Multi Classic: > 7000 points
  • Multi PowerUp: > 12000 points
  • Time Attack Classic: > 6000 points
  • Time Attack PowerUp: > 10000 points
• Negative scores (impossible under normal gameplay)
• Invalid difficulty/mode combinations
• Submission rate anomalies (via rate limiting)

Flagging Process:

• Suspicious scores are logged to PostgreSQL table: suspicious_scores
• Data stored: player_id, score, game_type, difficulty, reason (validation failure message), flagged_at (timestamp)
• Flagged scores are rejected (HTTP 400 Bad Request) - NOT saved to leaderboards
• Console log generated: 🚨 Score suspect: {playerId} - {score} pts ({reason})

Storage & Retention:

• Database: PostgreSQL (Neon) - table: suspicious_scores
• Retention: Indefinite (for fraud investigation and pattern analysis)
• Access: Internal review only (not shared with third parties)

Your Rights:

• Request deletion of flagged records via email: contact.thecatsizerlab@gmail.com
• Appeal false positives with evidence (screenshots, gameplay videos)
• GDPR Right to Erasure applies (Article 17) - unless fraud investigation ongoing

Purpose: Detect and prevent score manipulation, maintain leaderboard integrity, protect fair play

Legal Basis: Legitimate interest (fraud prevention - GDPR Article 6.1.f)

6.2 Organizational Measures

• Access to data limited to authorized personnel only
• Confidentiality agreements with all service providers
• Regular security audits
• Automated dependency updates and security patches

✋7. Your Privacy Rights

7.1 Right of Access (GDPR Article 15)

You can request access to your personal data.

How to Request:

• Email: contact.thecatsizerlab@gmail.com
• Response Time: 30 days

Data Accessible Directly:

• Purchase History: Google Play Store > Account > Payments and Subscriptions
• Google Privacy Settings: myaccount.google.com

7.2 Right of Correction (GDPR Article 16)

You can correct inaccurate data about yourself.

• Update your display name and preferences within the Application settings

7.3 Right to Erasure (GDPR Article 17)

You can request deletion of your personal data. However, certain data must be retained for the app to function properly.

🗑️What Can Be Deleted

🔒What CANNOT Be Deleted (Service Integrity)

The following data is essential for the app to function and cannot be deleted while you maintain an active account:

🔄How to Completely Remove Your Data

If you want to completely erase your presence from the app, you must:

1. Uninstall Sudoku Battle
   • Long-press app icon > Uninstall
   • Effect: All local device data deleted immediately
2. Request Server Data Cleanup (Optional)
   • Email contact.thecatsizerlab@gmail.com
   • Provide your player identifier, linked Google account email, or display name if known
   • We will delete: Orphaned server records (scores, friendships, etc.) within 90 days
   • We will retain: Purchase records (7 years - legal requirement)

⚖️GDPR Compliance Justification

We comply with GDPR while maintaining service integrity through these legal bases:

• Article 6.1.b (Contract Necessity): Your game data, stats, and friends are necessary to provide the service you signed up for. Deleting them would render your account non-functional.
• Article 17.3.b (Public Interest): Leaderboard integrity is a public interest for all competitive players. Retroactive score deletion would unfairly manipulate rankings.
• Article 17.3.b (Legal Obligation): Purchase records must be retained 7 years for tax compliance (French/EU law).
• Article 6.1.f (Legitimate Interest): Match history used for anti-cheat and matchmaking balance.

7.3.1 Partial Data Deletion

You can request deletion of specific types of data without deleting everything:

To request partial deletion: Email contact.thecatsizerlab@gmail.com with your Player ID and specify exactly which data you want deleted.

7.4 Right to Data Portability (GDPR Article 20)

You can request your data in a structured, portable format.

How: Email a request to contact.thecatsizerlab@gmail.com with proof of identity

7.5 Right to Object (GDPR Article 21)

• Personalized Ads: Modify your Google Ads settings
• Analytics: Opt-out via device privacy settings
• Marketing: Unsubscribe from marketing lists (if applicable)

7.6 Right to Restrict Processing (GDPR Article 18)

You can request to restrict certain processing of your personal data in specific situations defined by applicable law. To make a request, contact us by email.

⚖️8. Legal Compliance

8.1 GDPR (European Union)

Sudoku Battle complies with the General Data Protection Regulation (GDPR):

• Data Controller: TheCatsizerLab
• Legal Basis: Consent + Contract + Legitimate Interest
• Consent Process: Modal displayed on first launch
• Right to Withdraw: Changeable anytime in Settings > Privacy
• Data Processing Agreement: Available upon request

8.2 CCPA (California, USA)

For California residents, you have additional rights:

• Right to Know: Demand information on data collection
• Right to Delete: Request data deletion (with exceptions)
• Right to Opt-Out: Deny "sale" of personal information (see Section 9)
• Right to Non-Discrimination: No penalties for exercising your rights

CCPA Request Process: Send verified request to contact.thecatsizerlab@gmail.com with:

• Proof of identity
• Proof of California residence
• Detailed description of requested data

Response Time: 45 days

8.3 France - Loi Informatique et Libertés

Sudoku Battle complies with French Law n°78-17 of January 6, 1978:

• Data processing declarations compliant
• Right to object to processing
• Right of access to personal data
• DPO contact available

8.4 Other Jurisdictions

• UK: Compliant with UK GDPR
• Switzerland: Compliant with Federal Data Protection Act (LPD)
• Canada: Compliant with PIPEDA
• Australia: Compliant with Privacy Act 1988

🎯9. Consent & Controls

9.1 Essential Services

Sudoku Battle relies on certain services that are necessary to operate, maintain, and improve the Application. For this reason, we do not provide in-app switches to disable essential diagnostics and basic usage measurement.

• Diagnostics & Stability: We use crash reporting to detect, investigate, and fix bugs and technical issues.
• Security & Abuse Prevention: We apply technical measures to protect the Application and prevent misuse.
• Basic Usage Measurement: We collect limited usage information (e.g., screens viewed, session duration, feature usage) to improve performance and gameplay.

Legal Basis: Legitimate Interest (GDPR Article 6.1.f) and/or Contract Necessity (GDPR Article 6.1.b), depending on the context and the data involved.

9.2 Identification Choice Control

Unlike the essential services above, your identification method (Google Sign-In vs. guest) is a genuine choice you make on first launch, and you retain control over it afterward:

• You can secure a guest account with Google Sign-In at any time from your profile settings, which links your existing progress to your Google account
• Declining Google Sign-In does not prevent you from using the Application — the guest identifier provides full access to all game features

9.3 Advertising Controls (Google)

The Application displays ads using Google AdMob. Ad delivery and personalization preferences are primarily managed by Google through your device and Google account settings.

• You may be able to control ad personalization via your Google account and Android privacy settings.
• You may reset or limit the use of your Advertising ID via Android settings.

Note: The availability of certain ad controls depends on your region, device, and Google settings.

9.4 How to Stop Data Collection

You can stop all data collection from the Application by uninstalling it. You can also clear local data via Android Settings (this removes locally stored preferences and progress saved on the device).

🍪10. Cookies & Tracking Technologies

10.1 Local Storage

The app uses SharedPreferences (Android local storage) to store:

• User preferences (theme, language, audio settings)
• Session tokens (JWT authentication)
• Consent status (privacy preferences)
• Match history (last 5 matches)
• Achievement progress tracking
• Audio preferences (volume, enabled/disabled)
• Identification choice status (whether you have already chosen Google Sign-In or guest)

Technically these are not "cookies" but persistent local files.

10.2 Firebase Analytics & Crashlytics

📊Firebase Analytics

Google Firebase Analytics collects usage data automatically:

• Game events: Match start, victory, defeat, abandonment (manually logged via code)
• App performance metrics: Session duration, screen views, app startup time
• User properties: Device type, OS version, app version, user cohorts
• Ad interaction events: Ad impressions, clicks, rewarded ad completions

Storage & Retention: Analytics data is processed and retained under Google's Firebase Analytics policies and configuration. Retention settings may vary and are managed by Google.

Legal Basis: Legitimate interest (GDPR Article 6.1.f - analytics for service improvement)

⚠️Firebase Crashlytics

Automatic crash reporting system (see Section 3.2 for full details):

• Crash reports: Fatal errors with stack traces
• Device state: Memory, storage, battery at crash time
• Session data: App version, crash timestamp

Storage & Retention: Crash reports are processed and retained under Google's Firebase Crashlytics policies and configuration. Retention settings may vary and are managed by Google.

Legal Basis: Legitimate interest (technical maintenance)

User Controls:

• In-app controls: The Application does not provide in-app switches to disable essential diagnostics or basic usage measurement.
• Device/Google controls: Some advertising-related settings (such as ad personalization and Advertising ID controls) may be available through your Android device settings and Google account settings.
• Stop collection: Uninstalling the Application stops all data collection from the app.

10.3 Google Advertising ID

Google assigns you a unique advertising ID for:

• Targeted ads in AdMob
• Ad frequency limiting
• Campaign performance measurement

Manage: Settings > Google > Manage Account > Privacy > Ad Settings

Reset: Settings > Google > Privacy > Reset Advertising ID

10.4 Tracking Links (UTM)

Promotional links may include UTM parameters to measure campaign effectiveness.

👶11. Children's Privacy (COPPA & GDPR)

11.1 Age Requirements

• US (COPPA): ≥ 13 years old
• Europe (GDPR): ≥ 16 years old (varies by country)
• France: ≥ 13 years old

11.2 Minors' Data Protection

If you are under the age of digital consent in your jurisdiction:

• Your data receives enhanced protection
• Parent/guardian consent is required
• Data collection is minimized
• No profile-based ad targeting
• Data deletion upon reaching majority (on request)

11.3 Parental Controls

Parents/guardians can:

1. Restrict IAP: Google Play > Parental Controls > Require Authentication
2. Limit Ads: Disable personalized advertising
3. View History: Google Play Family Library
4. Delete Account: Request via email with proof

11.4 Report Inappropriate Content

If you find content unsuitable for children: contact.thecatsizerlab@gmail.com with screenshot

🌍12. International Data Transfers

12.1 Server Locations

• Europe: Google Cloud (Frankfurt/Ireland)
• Outside EU: Data shared with Google (USA-based)
• Fly.io: Decentralized CDN infrastructure (USA)

12.2 Legal Safeguards

For transfers outside EU to USA, we rely on:

• Standard Contractual Clauses (SCCs): EU-USA model
• Google Data Processing Terms: SCC-compliant
• Adequacy Decisions: Switzerland/UK/Canada recognized

12.3 Your Control

You can request:

• Copy of contractual safeguards
• Information on specific transfers
• Limitation of transfers (may impact service)

📝13. Policy Changes

13.1 Right to Modify

We may update this policy for:

• Legal compliance changes
• Error corrections
• Practice changes
• Clarifications

13.2 Notification

• Major Changes: In-app notification 30 days before
• Minor Changes: Published on this page with date
• Acceptance: New consent required for major changes

13.3 Version History

📞14. Contact & Complaints

14.1 Questions or Issues

14.2 File a Complaint with Authorities

If you believe we violate your rights, you can lodge complaints with:

• CNIL (France): www.cnil.fr
• Your Country's DPA: Contact your local data protection authority
• CCPA (California): California Attorney General
• OAIC (Australia): www.oaic.gov.au

14.3 Complaint Procedure

Before escalating to authorities:

1. Contact us directly (see 14.1)
2. Allow 30 days for resolution
3. Provide evidence of resolution attempts

ℹ️15. Additional Information

15.1 Sensitive Data

We NEVER collect:

• ❌ Biometric data
• ❌ Health data
• ❌ Genetic data
• ❌ Religious/political beliefs
• ❌ Sexual orientation data
• ❌ National ID numbers

15.2 Profiling & Automated Decisions

• Multiplayer Matching: Algorithm by level/rank (no profiling)
• Theme Recommendations: Usage statistics only
• Ads: Google targeting (you control)
• No automated decisions affecting your rights

15.3 External Links

This policy does NOT cover:

• Google Play Store
• Google Services (Gmail, YouTube, Google Sign-In account settings, etc.)
• External websites

Please review their privacy policies separately.

⚡16. Final Provisions

16.1 Complete Agreement

This policy is the complete agreement between you and TheCatsizerLab regarding personal data processing. It supersedes all previous versions.

16.2 Severability

If any provision is invalid, remaining clauses remain enforceable.

16.3 No Waiver

Non-exercise of a right does not constitute waiver of that right.

16.4 Governing Law

• Jurisdiction: Zigliara, South Corsica, France
• Governing Law: French Law + GDPR
• Competent Courts: District Courts of Ajaccio, Corsica

16.5 Prescription Period

GDPR rights must be exercised within 3 years of becoming aware of the violation.

📚17. Glossary

❤️Thank You

Thank you for taking the time to read our privacy policy. Your trust is important to us.