VaultX

Bugs have been fixed, and the plugin now offers a better user experience and additional features. ​

Bug fixes and optimizations. ​

· Dynamic Pricing & Inflation Engine (DynamicPricingManager): Added an automated macroeconomic inflation engine that measures total circulating money supply in real time (RAM balance cache + SQL database balance sums). Calculates an Inflation Index Multiplier ($M$) based on a reference baseline money supply ($B$), elasticity factor ($k$), and configurable bounds ($M_{min}, M_{max}$), dynamically adjusting server buy/sell prices and tax rates to preserve economic balance. · Custom Bukkit Event (VaultInflationUpdateEvent): Integrated an asynchronous Bukkit event VaultInflationUpdateEvent dispatched whenever inflation multipliers or money supply ratios are recalculated. Allows third-party shop plugins, eco addons, and custom scripts to react to server market fluctuations. · Comprehensive PlaceholderAPI Support for Dynamic Pricing: Added a full suit of new PlaceholderAPI placeholders for server shops, scoreboards, and HUDs: · %vaultx_inflation_multiplier% & %vaultx_inflation_multiplier_<currency>% (e.g. 1.20) · %vaultx_inflation_percent% & %vaultx_inflation_percent_<currency>% (e.g. +20.0%) · %vaultx_dynamic_price_<basePrice>% & %vaultx_dynamic_price_formatted_<basePrice>% (e.g. $120.00) · %vaultx_dynamic_sell_price_<basePrice>% & %vaultx_dynamic_sell_price_formatted_<basePrice>% · %vaultx_dynamic_tax_<baseTax>% (e.g. 2.40%) · %vaultx_money_supply% & %vaultx_baseline_supply% · Dynamic Pricing Administrative Commands (/vx dp): Introduced a new suite of admin commands under /vx dynamicpricing (aliases: /vx dp, /vx dynamic): · /vx dp info: Displays a formatted macroeconomic status card showing money supplies, baseline values, inflation index multipliers, elasticity, and bounds for all registered currencies. · /vx dp setbase <amount> [currency]: Manually configures the baseline money supply reference. · /vx dp recalculate: Triggers an immediate non-blocking money supply recalculation. · /vx dp calc <basePrice> [currency]: Interactive simulation tool to preview adjusted buy and sell prices in real time. · Strict Command Permissions System: Updated plugin.yml and VaultXCommand to enforce strict permission nodes for every single command and subcommand. Implemented dynamic permission checking via checkPermission, respecting custom permissions configured per command inside config.yml while falling back to defaults (vault.use, vault.command.money, vault.command.pay, vault.top, vault.command.bank, vault.command.loan, vault.command.mailbox, vault.command.escrow, vault.command.stocks, vault.convert, vault.command.check, vault.command.payday, vault.command.transactions, vault.command.subscribe, vault.admin). · High-Performance SQL Money Supply Aggregation: Added getTotalCurrencyBalanceSum(currency) to LocalFailoverManager, executing optimized SUM(balance) queries on SQLite/MySQL tables off the main thread for accurate money supply tracking across default and custom multi-currency accounts. · Full Multi-Currency Dynamic Pricing Integration: Dynamic pricing automatically detects all registered custom currencies (e.g. Gems, Tokens) and calculates independent inflation indices per currency. Step into the future of Minecraft Economy. Install VaultX v1.1.0 now!​

· Bukkit Main Thread Economy Synchronicity: Refactored SubscriptionManager, LoanManager, PaydayManager, StockExchangeManager (bank dividends), PhysicalEconomyListener (check claiming), and all VaultXGUI / ExchangeRateManager transactions to dispatch economy deposits, withdrawals, bank balance queries, and bank withdrawals synchronously on the Bukkit main thread. This completely resolves severe thread-safety/concurrency issues when using third-party economy plugins that are not thread-safe. · Scheduler Concurrency & Wealth Tax Fixes: Resolved database write race conditions in LoanManager and SubscriptionManager by accumulating updates in-memory and saving them asynchronously in a single batch. Fixed the Central Bank wealth tax double-taxation bug on default currency and ensured custom currency taxes are correctly credited to the Treasury when interest is disabled. Offloaded all remaining database transaction logging to async threads. · Automated Database Pruning: Added a configurable storage.transaction-history-retention-days setting (defaulting to 30 days) to automatically prune old entries in the player_transactions and security_audits tables during background analytics runs, preventing database bloat. · Performance Optimizations (BFS Circular Transfer): Replaced the recursive DFS algorithm for circular transfer check in TransactionFirewall with an iterative $O(V + E)$ Breadth-First Search (BFS), eliminating CPU lags and preventing any risk of StackOverflowError. · SQLite HikariCP Connection Pool & WAL Mode: Upgraded SQLite storage integration in LocalFailoverManager to use a high-performance HikariCP connection pool with Write-Ahead Logging (WAL) and Normal synchronous mode enabled, removing global read locks and allowing concurrent async database queries. · Non-Blocking UUID Cache & Negative Caching: Offloaded local SQLite and Redis UUID cache queries to an asynchronous task when resolving offline players on the main thread to completely eliminate any risk of main-thread lag. Additionally, implemented negative caching for non-existent player names (5-minute expiration, cleared upon join) to prevent scheduler and Mojang API spam from repeat lookup attempts. · Central Bank Multi-Server Protection & Sync: Configured distributed locks (central_bank_run) via Redis and economic settings timestamp checks to prevent duplicate interest/tax runs on multi-server networks. Optimized Redis sync payload to only transmit modified player accounts. · Security Firewall Operator Bypass: Added an exemption to the transaction security firewall (including single-transaction limit, circular transfer, and spike detection) for operators (/op) and players with the new vault.firewall.bypass or vault.admin permissions, preventing administrators from being blocked or frozen during testing or command executions. · Full English Localization & Fallback Translations: Translated all user-facing commands, help menus, GUI titles/lores, and default error warnings from French to English. Hardcoded French fallback strings inside the source code (including Forex events, Bourse announcements, Paydays, Loans, Subscriptions, and Security Alerts) are now fully localized to English. · Translatable Subsystems & Configuration Cleanup: Added new, configurable translation keys for Subscriptions, Central Bank, and the Security Firewall inside messages.yml for easy customization. Audited and removed all obsolete, duplicate, and unused legacy keys to optimize config file structure. · Java 21 Modernization: Updated compilation targets to Java 21 to take advantage of modern JVM performance gains, concurrent GC optimizations, and updated dependencies. · Check Redemption Inventory Safety (Check Loss Prevention): Refactored physical check claiming and check signing to verify inventory space. If a player's inventory is full when database updates fail during claim restoration or check signing, the check item is dropped naturally at their feet, preventing any item loss. · Macroeconomic Stats Command & GUI (/vx stats / metrics): Added a new admin command /vx stats (and alias /vx metrics) that displays a beautiful macroeconomic overview. Players with admin permissions will open a dedicated GUI panel showing global currency supplies, average balances, accounts count, Public Treasury reserves, active bank loans, outstanding garnishments, and a Rich List leaderboard. Running the command from the console or with the text argument displays these stats as clean text in the chat. · Interactive Transaction Logs Search (/vx logs <player> [page]): Added a /vx logs command allowing admins to view the last 10 transactions of any player in the chat. The query runs asynchronously off the main thread. On Spigot, logs are formatted as interactive chat components with hover details (showing raw type and category) and clickable pagination arrows. · Inflation Spike Detection & Discord Alerts: Extended the security firewall to periodically monitor the default money supply (every 5 minutes). If the total money supply increases by more than a configurable percentage (default 5.0%) within a sliding 1-hour window, the firewall generates warning logs and instantly dispatches an alert to the Discord Webhook to flag potential duplication bugs or corrupt administrative actions. · Robust Standalone & Redis Fallback Mode: Fixed several critical NullPointerExceptions in standalone mode when no economy delegate plugin is registered. Enabled full SQLite/MySQL local fallbacks for bank creation, deletion, deposits, and withdrawals when Redis is offline or disabled, ensuring seamless offline/failover operations. · Durability in Batch Writer Queue: Integrated database transaction success checks into the background batch writer loop. Drained records (transactions, audits, pending syncs) are now automatically re-queued on database lock or connection drop, preventing any silent data loss. · Asynchronous Circular Transfer Search: Refactored the firewall's circular transfer path-finding check to run asynchronously off the main thread. Transactions proceed instantly, and cycle detections are resolved in the background. If a loop is found, a task is scheduled on the next tick of the main thread to freeze the fraudulent accounts. · Aggressive Redis Connection Timeout: Reduced default Redis connection/socket timeout fallback from 2000ms to 250ms. If the Redis server lags or disconnects, VaultX instantly falls back to local database storage (SQLite/MySQL) without causing any main-thread freezes. · Leaderboard SQL Join Optimization: Updated the local leaderboard queries to perform a LEFT JOIN with the local_uuid_cache table, fetching player names directly from the database in a single query. This bypasses the synchronous Bukkit.getOfflinePlayer(uuid).getName() lookup loop, preventing severe lag spikes when opening the leaderboard GUI. · Asynchronous Local Database Writes: Offloaded synchronous database write operations (including saveUuidCache, saveBankBalance, deleteBankAccount, createBankAccount, updatePlayerStockShares, and updatePlayerDebt) to background threads. This prevents the Spigot main thread from blocking on disk E/S during joins, GUI clicks, and paydays. · Rate Limiter Memory Cleanup: Fixed a progressive memory leak in the transaction rate limiter by updating the background task to prune expired tracking entries (rateLimitWindow, rateLimitCount, rateLimitBlock) of offline players, keeping the heap footprint optimized. Step into the future of Minecraft Economy. Install VaultX v1.0.9 now!​

This release resolves critical compatibility issues and ensures seamless plug-and-play functionality for servers migrating from legacy Vault to VaultX: · Full Legacy 'Vault' Compatibility: Changed the internal plugin name back to Vault. This ensures that all plugins checking for a plugin named "Vault" (such as Skript, CMI, ShopGUI+, or various shop plugins) can immediately hook into the economy services without errors, restoring native variables like {money} / {total money}. · Seamless Data Folder Auto-Migration: Added a startup migration engine that checks if the new plugins/Vault folder exists. If not, and an existing plugins/VaultX folder is detected, it automatically renames/migrates the folder. This ensures you do not lose configurations (config.yml, gui.yml, messages.yml) or database files (failover.db). · PlaceholderAPI Parameter Normalization: Updated the built-in PAPI expansion parser to automatically strip the eco_ prefix from query parameters (e.g. eco_balance becomes balance). This allows layouts referencing standard formats like %vaultx_eco_balance% or %vaultx_eco_balance_formatted% to work seamlessly. · Resource Packaging Fixes: Resolved a resource resolution error by packing gui.yml correctly within the Maven compiler shade targets, preventing startup IllegalArgumentException errors. · Built-in Update Checker: Added a new asynchronous update check system at startup to notify you of new VaultX updates. This can be configured/toggled under the new settings.check-updates option in the config.yml. · 100% Configurable GUI Layouts: All dashboard buttons and navigation items (exchange, history, mailbox, stocks, escrow, loans, and back buttons) can now have their positions fully customized by adding a slot: X parameter directly in gui.yml. If no slot is defined, the menu defaults to the standard layout. · Direct Root Commands (Shortcuts): All major economy features are now accessible via fast, direct root commands without needing the /vaultx prefix! You can now type /money, /pay, /baltop, /bank, /loans, /exchange, /stocks, /escrow, /mailbox, and /check natively. · Recurring Payments & Subscriptions: Introduced a complete recurring billing engine. Players can set up automated periodic payments for guild fees, shop rents, or services using /subscribe create <target> <amount> <hours> [currency]. Includes auto-suspension on insufficient funds with mailbox notification, listing, resuming, and canceling active subscriptions. · Dynamic Commands & Custom Aliases: Admins can now fully customize, rename, disable, define custom aliases, and specify custom permissions for all 14 economy shortcut commands (including /money, /pay, /subscribe, etc.) directly in the config.yml at runtime. Features a single-pass unregistration optimizer (14x faster loading) and robust dynamic cleanup mechanisms to prevent duplicate commands during server hot reloads. · Complete Config.yml Optimization: Fully aligned the config.yml file with the Java backend. Added configuration keys for the new subscription engine (enabling, active limits, scheduler check frequency), exposed previously hidden bank loan configuration options (base interest rate, billing interval), and added the new custom command management section. · ATM Signs Compatibility (1.14+): Resolved a legacy compatibility bug where clicking physical ATM signs would fail on Minecraft versions 1.14 and higher (including 1.21.4) by migrating from wood-specific materials to a unified block-state detection. · Stock GUI Icon Fix: Corrected the Iron commodity item representation in the Stock Exchange GUI to display a proper Iron Ingot (IRON_INGOT) instead of a placeholder barrier block. · Native Fallback Economy Mode: If no external economy provider is registered at startup, VaultX will automatically register itself as the primary economy provider. Default balances are stored natively in the Redis/SQLite database, preventing "No economy provider is registered!" errors on standalone setups. · Case-Insensitive Currency & Symbol Matching: Resolved casing lookup issues for custom currencies (e.g., /bal tokens, /bal TOKENS). Casing is normalized automatically against supported currencies. · Custom Currency Chat Symbols: Added a new currency-exchange.symbols configuration section in config.yml allowing admins to define custom symbols (with color code support, e.g. &b✪ for Tokens or &a✦ for Gems) to represent custom currencies in chat messages, payments, leaderboards, and physical checks, replacing the default $ formatting. · Tab-Complete Recursion Fix: Resolved a critical StackOverflowError in the dynamic command tab-completer caused by recursive calls when processing shortcut command arguments. · Offline Player Lookup Cache Fix: Fixed UUIDCache to prevent caching non-existent players or currency typos during command target resolutions, ensuring that lookup commands accurately report "Player not found" when a player does not exist. · HikariCP & Prepared Statement Caching: Replaced the basic custom database pool for MySQL/MariaDB with HikariCP, the fastest connection pool for Java. Included native Prepared Statement caching configuration keys to reduce SQL statement recompilation overhead and garbage collection pressure under heavy transaction loads. · Asynchronous UUID Resolution & Anti-Lag Engine: Rewrote player name-to-UUID resolution to execute Mojang API web queries strictly off the main thread. If a command uses an un-cached player name, VaultX will resolve it asynchronously in the background and return immediately. This eliminates main thread freezing and protects servers from lag spikes and crash exploits caused by spamming unrecognized player names. · Async Join Cache Warming: Implemented pre-login balance warming by intercepting AsyncPlayerPreLoginEvent. Warmed balances are promoted from the offline cache to the primary memory cache in $O(1)$ time upon player join, eliminating synchronous database and Redis queries on the server's tick loop when players connect. · Negative Account Caching: Added a negative lookup caching system (30 seconds TTL) for offline players who have never played before. This prevents scoreboards, tab lists, and other plugins from generating redundant database queries for non-existent accounts. · Debounced Redis Pub/Sub Updates: Implemented write-coalescing (debouncing) with a 200ms window for Redis Pub/Sub balance updates. Multiple micro-transactions within a short timeframe (e.g. buying chest shop items one-by-one) are consolidated into a single network broadcast, drastically decreasing Bungee/Velocity cross-server message traffic. Includes a synchronous flushing hook on server shutdown to ensure zero data loss. Step into the future of Minecraft Economy. Install VaultX v1.0.8 now!​

This release brings comprehensive optimizations, thread safety, and critical bug fixes to ensure high performance and reliability: · Database Indexing Optimization: Added crucial SQL indexes on the player transactions, mailbox, bank members, local escrows, and webhook retry tables, replacing slow sequential scans with instant O(1)/O(log N) lookups. · Jedis Redis Pipelining: Implemented bulk balance and bank update publishing using Redis command pipelining, resolving connection pool exhaustion and significantly reducing network round-trip latency. · Central Bank Sync Engine Overhaul: Optimised the network-to-database synchronization loops to eliminate redundant DB writes, minimize ServiceProvider lookups, and streamline background tasks. · Non-Blocking Async Commands: Moved all main-thread blocking operations for command executions (such as /vaultx bank balance and /vaultx exchange) to asynchronous Bukkit scheduler tasks, ensuring stable server TPS. · UTF-8 usercache.json Preload: Fixed a character encoding issue by forcing UTF-8 when parsing player profiles from usercache.json, preventing player name corruption on systems with non-UTF-8 default system charsets. · PlaceholderAPI Expansion Fixes: Rewrote the placeholder handler to support omitting currency parameters in leaderboards (automatically defaulting to "default"), validate custom currencies to avoid conflicts with other expansions, and safely handle null players and unrecognized parameters. · Shared Guild Banks Invitation Engine: Added an invitation system to shared banks (/vx bank invite/accept/deny/invites) with role enforcement (OWNER, MANAGER, MEMBER, VIEWER), fully synchronized across servers via Redis PubSub. · Direct Visual Transaction Ledger: Enabled /vx history and /vx ledger commands to immediately open the high-performance visual Chest GUI showing recent deposits, withdrawals, and transfers. · Asynchronous Group Salaries (Paydays): Added group-based pay allocations (integrating with Vault permissions like LuckPerms) with automatic tax deductions directed to the public treasury, running asynchronously to protect server TPS. · Premium Discord Webhook Alerts: Added real-time admin notification webhooks for dynamic Forex market events (booms and crashes) and successful transactions exceeding a configurable large-amount threshold. · Comprehensive Message Localization (messages.yml): Moved all hardcoded chat, title, and console messages across all subsystems (commands, bank, payday, firewall, central bank, escrow, mailbox) to a fully customizable configuration file supporting color codes. · Physical Checks & ATMs: Added physical economy support with sign-based ATMs and signed paper checks (/vx check write) verified asynchronously via lore with thread-safe double-spending prevention. · AML Circular Fraud Detection: Implemented directed graph cycle detection (DFS/BFS pathfinder) inside a sliding time-window, automatically freezing accounts and alert-logging circular money laundering schemes. · Virtual Forex & Commodities Market: Expanded the main dashboard to include /vx stocks Chest GUI. Players can buy/sell fluctuating commodities (Gold, Iron, Emerald, Diamond) and trade shared bank shares with hourly dividend payouts. · Loans & Wage Garnishment: Implemented automated loan contracts with hourly billing installments, credit limits, and automatic payday salary garnishment upon default. · Scoreboard Balance Caching Fix: Implemented a configurable, short TTL (default 1 second) for online player balance cache, ensuring scoreboard placeholders (like TAB's %vault_eco_balance_formatted%) stay updated when other plugins modify user accounts. · Comments-Preserving Auto-Updater: Built a custom YAML configuration updater that dynamically merges new keys into config.yml and messages.yml upon plugin load without losing comments or resetting user values. · Customizable GUI Layouts (gui.yml): Added a separate gui.yml configuration file to customize sizes, titles, materials, item names, and lore descriptions for all VaultX interfaces (Dashboard, Stocks, Loans, History, Exchange, Escrow, Mailbox). · Full English Translation & Localization: Translated all internal configuration comments, GUI labels, item descriptions, and chat notifications into English to make the plugin natively global and easier to configure. Step into the future of Minecraft Economy. Install VaultX v1.0.7 now!​

This release introduces major under-the-hood engine overhauls to scale VaultX to high-traffic servers with zero lag: · Non-Blocking SQLite WAL Concurrency: Decoupled SQLite read and write connections, allowing concurrent reads on the the main thread during heavy background disk writes to completely prevent lag/tick spikes. · O(1) Player Cache Invalidation: Restructured balance caches to use nested player-specific maps, allowing instant O(1) invalidations upon player disconnects and eliminating O(N) key scans. · Non-Blocking Offline Player Resolution: Introduced reflection-based detection for Spigot/Paper's getOfflinePlayerIfCached, bypassing slow Mojang API queries and resolving player identities instantly. · Atomic Redis Telemetry & Lua Statistics: Replaced heavy and blocking Sorted Set scans (zrange 0 -1) with atomic Lua script counters and dedicated cache keys to query global money supply instantly in O(1). · Fast Startup Preloading via usercache.json: Replaced slow Bukkit.getOfflinePlayers() disk-scan with rapid background parsing of usercache.json, achieving startup preloads in milliseconds. · Secure Spike Detection Transaction Validation: Reorganized the Firewall's spike detection to count transactions only after they successfully complete, avoiding pollution from failed or blocked deposits. Step into the future of Minecraft Economy. Install VaultX v1.0.6 now!​

This major feature release introduces a fully-featured Forex Market with dynamic exchange rates, a Central Bank with taxes and interest systems, a sleek interactive GUI dashboard, Shared Bank Accounts with role permissions, and an offline Mailbox system, alongside our secure Escrow engine, Latest-Write-Wins (LWW) data sync, resilient Discord webhooks, and advanced telemetry analytics. · NEW: Sleek Interactive GUI Dashboard (/vx menu / /vx gui) Manage your finances in a high-fidelity visual interface supporting modern and legacy versions (1.8 to 1.20+): · Dashboard Overview: View all your multicurrency balances (Dollars, Gems, Tokens) at a single glance. · Forex Exchange Bureau: Exchange currencies in a visual cyclical selector with live rate calculations and transaction fees. · Transaction History: Inspect your last 10 transaction records (deposits, withdrawals, categories, timestamps) directly in-game. · Mailbox & Escrow Integration: Quick access to claim your offline payments or manage pending escrow trades. · NEW: Dynamic Forex Market & Fluctuations Transform your flat economy into a living, breathing simulated currency market: · Real-time exchange rate calculations between customizable currencies (Gems Dollars Tokens). · Market Events: Random periodic events (e.g. "Economic boom on Gems (+18%)", "Market crash on Tokens (-15%)") trigger global server broadcasts and warning sounds. · Normal market fluctuations update at customizable intervals, allowing players to speculate and invest. · NEW: Central Bank & Fiscal Inflation Control Take control of server inflation with automated fiscal policies: · Taxes: Customizable transaction taxes on standard player transfers and currency conversions. · Interest Rates: Scheduled payouts yielding interest on online/offline player balances to reward savings. · Wealth Tax (ISF): Automatically levy tax percentages from players exceeding configurable balance thresholds, transferring the collected funds directly to the State Treasury. · NEW: Shared Bank Accounts with Role-Permissions Perfect for guilds, factions, or town teams to manage joint capital safely: · Create shared vaults with customizable member access. · Granular Roles: Assign roles like OWNER (full settings), MANAGER (withdraw/deposit, invite members), MEMBER (withdraw/deposit with daily limits), and VIEWER (balance-viewing only). · Fully synchronized across instances via Redis cache updates and SQLite failover syncing. · NEW: Offline Mailbox System (Boîte de Réception) Ensure players receive payments even while offline: · Seamlessly send money to offline players; transactions are held securely in a global failover mailbox. · Join Alerts: Offline players are greeted with visual actionbar title notifications and sound cues upon logging back in. · Claim individual payments or claim all with a single click in the GUI menu. · NEW: Secure Cross-Server Escrow Engine (Séquestre) Need to trade high-value assets securely across different Spigot instances? The new Escrow system guarantees transactional safety: · Start trades with /vx escrow start <receiver> <amount> [currency] to deduct and lock funds. · Confirm delivery and release the funds to the receiver with /vx escrow release <id>. · Cancel and refund back to the sender with /vx escrow refund <id> (sender can refund after timeout expires; receiver/admin can refund immediately). · Completely managed via Redis distributed mutex locks to prevent race conditions and double-spending across instances. · Asynchronous fallback tasks auto-refund expired escrows to ensure players never lose money due to server crashes. · NEW: Latest-Write-Wins (LWW) Data Reconciliation Protects player balances from diverging across server instances during Redis network splits: · Custom currency balances are stored with a last_updated versioning timestamp. · Upon reconnecting to Redis, VaultX compares the local database update timestamps against Redis global values and applies the latest write automatically. · Eliminates money duplication or rollback exploits caused by cross-server hopping during database outages. · NEW: Resilient Discord Webhook Retry Queue Ensures that critical security logs (Spikes, Rate Limits, auto-freezes) are never lost due to Discord API downtime or Rate Limiting (HTTP 429): · Failed security alerts are automatically persisted to the local pending_webhooks database table. · A background worker retries failed webhooks asynchronously using an Exponential Backoff pattern (15s * 2^attempts). · Honors Discord's Retry-After headers to handle rate limits precisely. · NEW: Real-time Telemetry & Diagnostics (/vx admin stats) Administrators can now monitor system performance, latency, and money supply statistics in real-time: · Cache Hit Rate: View the exact ratio of queries served in O(1) from RAM versus database hits. · DB Latency: Tracks the average execution time of the background asynchronous batch writer thread. · Redis Status: Real-time connection health state (ONLINE/OFFLINE). · Money Supply: Displays total money in circulation, total registered accounts, and average balances per player for every configured currency. · NEW: Inflation Analytics & Ledger (/vx admin report) Understand your economy's trends and sources of inflation easily: · Automatically categorizes every transaction under specific labels (e.g. SHOP, QUEST, ADMIN, JOB) by analyzing caller namespaces. · Background daemon runs daily aggregation tasks to store transaction flows in daily_analytics. · Run /vx admin report [days] to generate a clean breakdown of currency creation/destruction per category. · IMPROVEMENT: High-Performance Database Batch Writes (O(1) IO Queue) All fallback local database writes are routed through a highly efficient producer-consumer architecture: · High-frequency transaction logs, security audits, and offline player balance syncs are pushed to thread-safe queues. · A dedicated daemon worker thread (VaultX-BatchWriter) runs asynchronously, draining these queues every 1 second. · Queued records are executed in a single transaction using JDBC batch operations (addBatch/executeBatch), reducing disk writes by up to 50x-100x and eliminating SQLite/MySQL connection locks. · Fully thread-safe, non-blocking on shutdown: the queue drains completely to disk when disabling the plugin, preventing any data loss. · IMPROVEMENT: Database Query Indexing (Full-Table Scan Resolution) Eliminated full-table scans when querying transaction history or admin security logs: · Automatically creates composite database indexes (uuid, id) on the player_transactions and security_audits tables. · Optimizes administrative lookups like /vaultx transactions and /vaultx admin audit [player] for instant results, even with millions of rows. · Older MySQL Compatibility: Implemented real-time index presence verification via information_schema.statistics to completely bypass syntax limitations and startup warning issues on older MySQL (pre-8.0.30) and MariaDB versions. · IMPROVEMENT: Redis Backoff & Jitter Reconnection (Storm Prevention) Restructured Redis connectivity check to be network-friendly: · Replaced the static, rigid 5-second connection check timer with a self-rescheduling asynchronous task loop. · Exponential Backoff: If Redis connection is lost, reconnect intervals grow progressively (e.g. baseDelay * 1.5^attempts), capped at 60 seconds, preventing connection storms. · Randomized Jitter: Adds +/- 20% randomized jitter to reconnect delays to stagger reconnec

The major storage and leaderboard update is here! VaultX now supports native MySQL/MariaDB central databases, dynamic JDBC driver loading, cross-network ZSET-backed Redis Wealth Leaderboards, in-game transaction logging, and robust PlaceholderAPI top-wealth placeholders. · NEW: Native MySQL & MariaDB Database Support Expand your multi-server proxy setup (BungeeCord, Velocity) beyond SQLite. You can now use a centralized relational database for persistent failovers and logs: · Dynamic JDBC driver loading ensures driver conflicts are completely prevented. · Standardized REPLACE INTO queries to maintain absolute compatibility between SQLite, MySQL, and MariaDB. · Configurable connection pool sizing, connection timeouts, and database properties directly in the config.yml. · NEW: Global Wealth Leaderboards (Redis ZSET & PlaceholderAPI) Track the richest players across your entire server network in real-time: · Backed by ultra-fast Redis Sorted Sets (zadd) to process balance changes instantly. · Asynchronous background updates query top balances periodically to prevent network bottleneck. · Full PlaceholderAPI expansion support: - %vaultx_top_name_<position>_<currency>% - %vaultx_top_balance_<position>_<currency>% - %vaultx_top_balance_formatted_<position>_<currency>% · NEW: In-Game Transaction History Logs & Command Give players full transparency over their account movements: · Every single withdrawal, deposit, and custom currency transfer is automatically recorded locally. · Players can query their own transaction histories with /vaultx transactions [page] (or /vaultx tx). · Shows timestamp, type of transaction, amount, currency, and the caller plugin. · NEW: Global Wealth Leaderboard Command · Query top lists directly in-game: /vaultx top [currency] [page] (or /vaultx rich). · Supports custom currencies and full chat pagination. · NEW: Enterprise-Grade Performance & Stability Optimizations Massive internal engineering overhaul to ensure maximum TPS stability under extreme server load: · Non-Blocking SQL Connection Pool: Replaced class-level synchronized database queries in LocalFailoverManager with a thread-safe, lightweight connection pool based on BlockingQueue for MySQL/MariaDB, preventing main-thread lag when background database writes occur. · SQLite WAL Mode & Isolated Lock: Enabled SQLite Write-Ahead Logging (PRAGMA journal_mode=WAL) and PRAGMA synchronous=NORMAL to speed up disk writes by 10x-100x, and isolated thread synchronization to a local lock object to allow concurrent non-blocking reads. · Functional Query Template Engine: Refactored all SQL writes and queries to use functional interfaces DbConsumer and DbFunction, guaranteeing that database connections are always safely retrieved and returned to the pool under all execution branches. · Async Database Command Offloading: Database queries for command transactions (/vaultx transactions) and admin security audits are now processed completely asynchronously, preventing any Main Thread spikes or freezes under SQLite/MySQL database load. · Ultra-Fast PlaceholderAPI Cache Engine: Implemented dynamic local caching of the active economy provider in our PlaceholderAPI expansion. This resolves synchronization lock contentions in Spigot's service manager during high-frequency tablist/scoreboard requests, and updates instantly via Bukkit's ServiceRegisterEvent. · Secure Join Cache Preloader: Split the player join cache warming sequence to fetch main balance accounts synchronously on the main thread (guaranteeing thread-safety for legacy plugins like CMI or EssentialsX) while querying custom currencies asynchronously where safe. · Async IO Failovers & Disk Writes: Relocated file-saving tasks for frozen players and custom currency backup database writes during Redis disconnects to background threads. · Asynchronous Bank Balance Preloading: Preloads all local database and Redis bank accounts at startup to completely eliminate synchronous database/network I/O when retrieving bank balances during gameplay. · Offline Player Balance Cache (TTL): Introduced a thread-safe 10-second cache (offlineBalanceCache) for offline players to bypass database queries during bulk lookups (such as leaderboards or GUIs). · Asynchronous Yaml Configuration Thread-Safety: Fully isolated and secured YAML configuration saves (by using local configurations in BankBackupManager and dedicated locks in TransactionFirewall) to prevent ConcurrentModificationException and filesystem write conflicts. · Robust SQL Connection Health Validation: Implemented automatic connection.isValid(2) checks in LocalFailoverManager to instantly recover from dead or timed-out database connections without throwing JDBC errors. · Memory Leak Prevention: Hardened the security rate-limiters and transaction firewall tracking layers to clean up player data immediately on disconnect (PlayerQuitEvent), and restricted deposit spike-detection to online players only to avoid storing offline transaction histories. · Thread-Safe Leaderboards: Enforced immutable collections on all leaderboard responses, preventing concurrent modification exceptions under heavy read pressure. · Bank Balance Sync Bugfix: Fixed a logic issue where bank balances queried while Redis was online returned 0.0 instead of querying Redis, ensuring synchronized bank balances across the proxy network. · Graceful Redis Offline Backup Recovery: Added automatic fallback to the local SQL database in BankBackupManager when Redis is disabled/offline, preventing a NullPointerException crash on startup. · FIX: Discord Webhook Configuration Path · Fixed security webhook alerts loading issue to correctly respect the config key path. · FIX: Compile-Time Warnings & Java 21 Modernization · Resolved Deprecated Bukkit Methods: Replaced legacy and deprecated Bukkit.getOfflinePlayer(String) calls with the non-blocking UUIDCache.getOfflinePlayerFast(String) wrapper, preventing thread blocks during user lookups. · Resolved Modern Java URL Construction: Updated the Discord webhook notifier security alerts to construct URL instances safely via URI.create().toURL(), eliminating JDK 20+ deprecation warnings. · UUID Cache Error Resolution: Fixed a compilation error regarding an unresolved uuid variable in the legacy player cache. · Code Cleanup: Pruned redundant @SuppressWarnings("deprecation") annotations across multiple classes to restore IDE compiler hygiene. · IMPROVEMENT: Transaction Engine Refactoring · Centralized Transaction Logic: Designed a clean functional interface EconomyTransaction and a unified executeTransaction helper method inside OptimizedEconomy.java. · Boilerplate Reduction: Refactored all currency and player withdrawals/deposits to route through the centralized transactional workflow. This removes duplicate logic for rate-limiters, transaction safety firewalls, asynchronous Redis distributed locks, in-memory cache updates, and custom transactional event triggers. · COMPATIBILITY: Native Java 1.8 Support · The entire suite of new multi-database and leaderboard features remains fully compiled under Java 8 bytecode specification. Step into the future of Minecraft Economy. Install VaultX v1.0.4 now!​

This new performance and stability patch pushes VaultX's infrastructure even further! We have optimized the SQLite persistence layer, redesigned the offline player UUID cache management, and introduced a dedicated asynchronous write queue to relieve the main Bukkit scheduler. · NEW: Persistent SQLite Connections (Zero I/O Bottleneck) Rather than opening and closing the database on every local transaction or security audit write, VaultX now reuses a single, synchronized persistent SQLite connection. · Reduced local database access times by over 95%. · Complete resolution of "database is locked" errors during concurrent write spikes. · Proper cleanup of PreparedStatements after each query execution. · NEW: Asynchronous Startup UUID Cache Pre-loading (Zero Join Lag) To prevent blocking synchronous web requests to Mojang's API when querying economy balances for offline players: · VaultX now pre-loads all known player profiles using Bukkit.getOfflinePlayers() asynchronously at server startup. · Resolves all player names and UUIDs in O(1) time in memory. · Eliminates synchronous lag spikes (TPS drops) during transactions targeting offline players. · NEW: Dedicated Single-Threaded Executor for Redis & SQLite Instead of saturating the native Bukkit scheduler with asynchronous tasks for every single transaction: · Centralized all Redis Pub/Sub publications and SQLite database writes into a dedicated single-threaded ExecutorService. · Ensures sequential, conflict-free database updates and eliminates race conditions. · Optimized CPU usage by avoiding the overhead of spawning ephemeral threads. · STABILITY: Proper Lifecycle Resource Cleanup (Zero Memory/Thread Leaks) · Added robust cleanup hooks to the plugin's onDisable() phase. · Cleanly shuts down the Jedis connection pool, the ExecutorService, and the active SQLite connection. · Prevents thread/connection leaks or locked files during plugin reloads (/reload) or server stops. · COMPATIBILITY: Native Java 1.8 Support · The plugin remains compiled and fully optimized under the Java 8 bytecode specification, guaranteeing complete compatibility with legacy platforms while fully leveraging JVM optimizations on Java 17 and 21. Step into the future of Minecraft Economy. Install VaultX v1.0.3 now!​

The biggest update since the Modern X project began! We have completely transformed Vault into an ultra-performance enterprise engine capable of running massive networks seamlessly with global synchronization, native multi-currency support, and advanced transaction firewalls.​ · NEW: Anti-Duplication Security Shield & Global Freezes​ Tired of macro users finding economy duplication glitches in GUIs? VaultX now intercepts every transaction with a thread-safe firewall and rate-limiter.​ · Instantly blocks transactions if a player exceeds the max-transactions-per-second limit.​ · Automatically places the player in a temporary cooldown lock.​ · Global Sync: Player freezes and unfreezes are propagated instantly to all other servers via Redis Pub/Sub.​ · Local SQLite fallback keeps state synchronized even during Redis outages.​ · NEW: In-game Security Audit Command​ Administrators no longer need FTP access to check transaction security logs!​ · Use /vaultx admin audit [player/all] [page] to view security warnings directly in-game.​ · Features sleek pagination, action highlighting, and precise timestamps.​ · Complete tab-completion support for all arguments.​ · NEW: Native Cross-Server Bank Engine​ Legacy economy plugins have terrible bank support. Vault Modern X now hijacks the entire Bank API and runs its own native, ultra-fast Bank system!​ · Global Synchronization across your proxy using a central Redis vaultx:banks hash.​ · Instant local cache updates via Pub/Sub (0 delay, 0 TPS drop).​ · Auto-Backup System: Automatically backs up Redis banks to a local YAML file every 30 minutes, and restores them automatically if your Redis server restarts empty!​ · NEW: Native Multi-Currency Fallback Engine​ Does your primary economy provider lack multi-currency support? VaultX has you covered!​ · Seamlessly configures alternate currencies (e.g., Gems, Tokens) using rates in config.yml.​ · Automatically stores custom currency balances in a local SQLite database and syncs them via Redis.​ · Fully compatible with auto-conversion and existing API methods!​ · NEW: Ultimate UUID Global Cache & Async Join Pre-loading​ Legacy plugins using Bukkit.getOfflinePlayer() freeze your server by making Mojang API requests.​ · Vault Modern X now maintains an asynchronous UUID <-> Pseudo cache in memory.​ · Resolves and caches all currency balances on player login asynchronously (Zero join lag).​ · Intercepts legacy String-based withdraw/deposit requests and resolves them locally in O(1) time.​ · NEW: Currency Auto-Exchange System​ · Easily define exchange rates in config.yml (e.g., 1 Gem = 1000$).​ · If a player attempts to purchase a 10 Gems item but has 0 Gems, Vault automatically converts 10,000$ from their main balance to fulfill the transaction. Seamless integration for all external plugins!​ · NEW: Vault Async Economy API​ Developers can now cast the Vault Economy to VaultAsyncEconomy to get access to 100% Asynchronous CompletableFuture methods for every transaction!​ · PERFORMANCE: Enterprise latency & Asynchronous SQLite​ · O(1) Redis Status Cache: Redis connection checks are now cached via an asynchronous heartbeat, removing blocking network round-trips from transaction paths.​ · Non-blocking local storage: All local failover operations (SQLite writes, balance queueing) have been offloaded to async Bukkit threads, ensuring zero main-tick disk activity.​ Step into the future of Minecraft Economy. Update now!​

· NEW: Full Configuration System (config.yml) Vault Modern X is now fully configurable! You can fine-tune every aspect of the engine without recompiling. · O(1) Cache Control: Enable or disable the high-performance memory cache instantly using economy.use-cache. · Transaction Debugger: Added economy.debug-transactions to log every async transaction to your console. Extremely useful for server admins tracking economy flows. · Redis Channel Customization: You can now set a custom redis.channel. Perfect for networks running multiple separate clusters (e.g., Factions and Skyblock) on a single Redis database! · Metrics Toggle: Added full control over bStats metrics reporting directly in the config. · CRITICAL: Multi-Currency API Signature Fixes Fixed a major compilation and runtime conflict with the legacy Vault API. · Signature Resolution: Solved the "Duplicate method" JVM error by properly distinguishing Multi-Currency methods (e.g., getCurrencyBalance()) from legacy world-based methods (getBalance(player, world)). · Seamless Integration: Custom currencies no longer shadow standard Vault economy calls. Your legacy plugins are 100% safe! · Codebase Optimization & Cleanup · Dead Code Elimination: Purged unused interceptor fields and redundant plugin instance variables to keep the memory footprint as low as possible. · Optimized Initialization: bStats and the Redis Manager are now elegantly initialized based on config state, preventing unnecessary connections. Keep your server's economy flying at lightspeed. Update now!​