Download File

# Anti-Dupe 3.3 ## Overview Anti-Dupe 3.3 is an advanced anti-duplication, inventory-integrity, transaction-monitoring, and server-security system for Paper Minecraft servers. Rather than relying solely on inventory scanning, Anti-Dupe combines: - Transaction accounting - Event verification - Cross-inventory auditing - UUID tracking - Trusted-plugin verification - Vanilla transaction validation - Bundle-aware accounting - Exploit fingerprinting - Recovery systems - Inventory rollback protection - Cross-server synchronization - Configurable administrative security controls Anti-Dupe is designed to preserve normal Minecraft mechanics while protecting server economies from duplication exploits, plugin bugs, inventory desynchronization, rollback exploits, custom storage exploits, unsafe item transfers, and unexpected item-generation paths. --- # Core Features - Immediate event-based verification - Hybrid inventory scanning - Transaction Ledger - Trusted Plugin Verification - Shop Plugin Compatibility - Vanilla Transaction Engine - Dedicated workstation transaction handlers - Bundle transaction protection - Recursive bundle-content accounting - Custom command transfer protection - Plugin-managed vault protection - Repeated small-transfer detection - Stack-safe accounting - UUID tracking for unique items - Stacked unique-item integrity protection - Cross-inventory duplicate detection - Automatic chunk scanning - Deep inventory auditing - Inventory rollback system - Safe removal & recovery - Exploit Fingerprint Database - World-aware protection rules - SQLite database support - MySQL database support - MariaDB database support - PostgreSQL database support - Automatic database migrations - Velocity/Bungee network support - Cross-server item tracking - Player transfer protection - OP whitelist protection - Creative-mode whitelist protection - In-game OP protection management - In-game Creative protection management - Automatic UUID resolution - Daily rotating log files - Discord webhook alerts - Multi-language support - Automatic language-file migration - Automatic malformed-language-file recovery - Console verbosity controls - Administrator whitelist - Original item preservation - Bundled administrator README - bStats metrics support --- # Trusted Plugin Framework Anti-Dupe maintains the trusted-plugin framework introduced during the 3.2 development cycle. Anti-Dupe does **not** trust every custom inventory. A custom inventory transaction is considered trusted only when BOTH conditions are met: 1. The inventory title matches an approved pattern. 2. The inventory originates from an explicitly trusted plugin. Example: ```yaml compatibility: external-plugin-inventories: enabled: true grace-delay-ticks: 4 trusted-plugins: - UltimateShop title-patterns: - shop - store - market ``` Additional compatible plugins may be added: ```yaml trusted-plugins: - UltimateShop - EconomyShopGUI - ShopGUIPlus ``` Matching is case-insensitive. This prevents Anti-Dupe from blindly trusting an inventory simply because its title contains words such as `shop`. --- # Shop Plugin Support Anti-Dupe supports trusted inventory-based shop systems while continuing to protect normal player inventories. Trusted purchases can: - Update the Anti-Dupe ledger - Register legitimately created items - Avoid duplicate false positives - Avoid unnecessary recovery records - Avoid unnecessary Discord alerts - Continue protecting the player's other inventory activity > ## ⚠️⚠️⚠️ Trusted Plugin Security Risk ⚠️⚠️⚠️ > > Adding a plugin to `trusted-plugins` tells Anti-Dupe to accept qualifying item transactions from that plugin as legitimate. > > This means Anti-Dupe may be unable to detect duplication glitches, item-generation bugs, or exploitable transaction errors originating inside that trusted plugin. > > If a trusted shop, crate, auction, reward, or economy plugin contains a bug that allows players to receive extra items, Anti-Dupe may treat those items as authorized. > > Only whitelist plugins that you: > > - Fully trust > - Keep updated > - Have tested carefully > - Obtained from a reputable source > - Actively monitor for exploit reports > > Keep the trusted-plugin list as small as possible. > > Removing a plugin from `trusted-plugins` restores normal Anti-Dupe enforcement for its inventory transactions. --- # Vanilla Transaction Engine Anti-Dupe 3.3 includes dedicated handling for Minecraft's vanilla item-transformation systems. Instead of treating every workstation operation as a generic inventory change, Anti-Dupe identifies the type of transaction being performed and verifies it according to the behavior of that workstation. Supported transaction handlers include: - Player 2×2 Crafting - Crafting Table - Anvil - Grindstone - Smithing Table - Stonecutter - Cartography Table - Loom - Villager Trading - Furnace - Blast Furnace - Smoker - Brewing Stand - Crafter - Bundles This greatly reduces false positives caused by virtual result slots, delayed inventory processing, nested inventories, and legitimate item transformations. --- # Crafting Protection Crafting is handled separately from generic inventory clicks. Anti-Dupe allows Minecraft to complete the transaction before validating the result. Example: ```text 1 Oak Log ↓ Minecraft Recipe ↓ 4 Oak Planks ``` Anti-Dupe recognizes the consumed ingredient and authorized recipe output instead of treating the four planks as unexplained item creation. Virtual crafting-result previews are excluded from owned-item totals until the player actually completes the craft. This protects: - Player 2×2 crafting - Crafting Tables - Normal clicks - Shift-click crafting - Repeated crafting operations --- # Workstation Protection Different Minecraft workstations behave differently. Anti-Dupe accounts for those differences when monitoring: ```text Crafting Smithing Anvils Grindstones Stonecutters Cartography Looms Villager Trading Smelting Brewing Automated Crafting Bundles ``` For example, an anvil result is a virtual preview until collected, while an item already sitting in a furnace output slot is a real stored item. Anti-Dupe distinguishes these cases instead of applying a single generic inventory formula to every workstation. --- # Transaction Handler Configuration Individual vanilla transaction handlers can be enabled or disabled. ```yaml transaction-handlers: crafting: enabled: true delay-ticks: 2 anvil: enabled: true delay-ticks: 2 grindstone: enabled: true delay-ticks: 2 smithing: enabled: true delay-ticks: 2 stonecutter: enabled: true delay-ticks: 2 cartography: enabled: true delay-ticks: 2 loom: enabled: true delay-ticks: 2 villager-trades: enabled: true delay-ticks: 2 furnace: enabled: true blast-furnace: enabled: true smoker: enabled: true brewing: enabled: true crafter: enabled: true bundles: enabled: true delay-ticks: 2 include-contained-items-in-accounting: true recursive-content-check: true ``` This allows individual systems to be disabled if a plugin or datapack significantly modifies vanilla behavior. --- # Bundle Transaction Protection Anti-Dupe 3.3 includes dedicated protection for Minecraft bundles. Items contained inside a bundle are included in conservation accounting rather than being treated as invisible storage. This prevents actions such as removing arrows from a bundle from incorrectly appearing as new item creation. Example: ```text BEFORE Bundle: Arrow x4 Player/Cursor: Arrow x0 TOTAL: Arrow x4 ``` After taking the arrows out: ```text AFTER Bundle: Arrow x0 Player/Cursor: Arrow x4 TOTAL: Arrow x4 ``` Result: ```text NET CHANGE: 0 STATUS: VALID ``` Anti-Dupe does **not** simply whitelist bundle interactions. If an exploit causes: ```text Before Total: 4 After Total: 8 ``` Anti-Dupe can still identify: ```text Unexplained Excess: 4 ``` and send the excess through the normal recovery and quarantine pipeline. Bundle protection can account for: - Taking items from bundles - Putting items into bundles - Cursor-held bundle operations - Inventory-held bundles - Nested bundle contents - Recursive contained-item accounting --- # Recursive Nested-Item Accounting When enabled: ```yaml transaction-handlers: bundles: include-contained-items-in-accounting: true recursive-content-check: true ``` Anti-Dupe counts the contents of nested item containers when calculating transaction totals. This is particularly important because moving an item: ```text Player Inventory ↓ Bundle ``` should not appear as item destruction. Likewise: ```text Bundle ↓ Player Inventory ``` should not appear as item creation. The total quantity remains authoritative. --- # Custom Command Transfer Protection Anti-Dupe 3.3 can monitor item-transfer commands such as `/gift`. This helps protect against exploits where a custom plugin moves or creates an item without passing through normal Minecraft inventory mechanics. Example configuration: ```yaml advanced-transfer-protection: command-transfers: enabled: true grace-delay-ticks: 4 include-ender-chests: true include-open-inventories: true capture-rollbacks-for-online-players: true monitor-all-plugin-commands: false monitored-labels: - gift - senditem - itemgift ``` Anti-Dupe compares quantities before and after the transaction. A legitimate transfer: ```text Sender: -64 Recipient: +64 ---------------- Net: 0 ``` A suspicious transfer: ```text Sender: 0 Recipient: +64 ---------------- Net: +64 ``` The unexplained quantity can enter the normal Anti-Dupe detection, recovery, and quarantine pipeline. Trusted shop plugins are not automatically trusted for arbitrary commands. --- # Plugin-Managed Vault Protection Custom private storage systems can create blind spots for traditional anti-dupe systems. Anti-Dupe 3.3 includes configurable monitoring for plugin-managed vaults and private storage. ```yaml plugin-managed-storage: enabled: true title-patterns: - vault - private vault - storage - player vault plugins: [] verify-open-close-conservation: true crosscheck-on-open: true state-save-delay-ticks: 3 closed-state-increase-action: audit ``` Anti-Dupe can: - Track player and vault quantities - Cross-check UUIDs when storage opens - Save observed storage fingerprints - Compare previous and current vault states - Record vault open/close activity - Detect unexplained storage increases Available closed-state actions: ```text ignore audit quarantine ``` `audit` is recommended when a storage plugin can legitimately modify vault contents while the vault is closed. --- # Repeated Small-Transfer Detection Some duplication techniques attempt to avoid detection thresholds by moving duplicated items in many small transactions. Anti-Dupe can aggregate suspicious activity over a rolling window. ```yaml repeated-small-transfers: enabled: true window-seconds: 30 maximum-single-delta: 16 event-threshold: 3 quantity-threshold: 8 ``` This allows Anti-Dupe to recognize a suspicious pattern even when no single transaction is large enough to trigger a normal threshold. --- # Identity Integrity Protection Items that Anti-Dupe considers unique are protected against stacked identity bypasses. If multiple supposedly unique items appear inside one stack, Anti-Dupe can: 1. Preserve the legitimate item. 2. Back up the unexplained excess. 3. Remove the excess. 4. Create a recovery entry. 5. Continue UUID tracking. Normally stackable materials can optionally be forced into unique-item semantics: ```yaml identity-integrity: enabled: true force-unique-materials: [] ``` Use `force-unique-materials` carefully because forcing a normally stackable material into unique semantics intentionally changes how Anti-Dupe treats that item. --- # Scanner Configuration ```yaml scanner: enabled: true online-inventory-minutes: 5 ender-chest-minutes: 10 loaded-containers-minutes: 15 uuid-crosscheck-minutes: 15 ledger-audit-minutes: 30 players-per-batch: 10 automatic-chunk-scans: true chunk-scan-delay-ticks: 20 ``` Scanner tasks are staggered to minimize server impact. --- # Scan Frequency | Scan | Default | |------|--------:| | Online Player Inventories | Every 5 minutes | | Ender Chests | Every 10 minutes | | Loaded Containers | Every 15 minutes | | Cross Inventory UUID Check | Every 15 minutes | | Ledger Audit | Every 30 minutes | --- # Immediate Event Verification Anti-Dupe monitors inventory activity around Minecraft transactions. Protected activity includes: - Inventory Click - Shift Click - Number Key Swap - Drag Distribution - Stack Split - Stack Merge - Double Click Collect - Offhand Swap - Hopper Transfer - Item Pickup - Item Drop - Bundle Pickup - Bundle Placement - Crafting - Smithing - Anvil - Grindstone - Stonecutting - Cartography - Loom Operations - Villager Trading - Smelting - Brewing - Crafter Operations - Player Login - Player Logout - Container Open - Container Close Cursor items and nested bundle contents are included where appropriate to prevent legitimate inventory movement from appearing as duplication. --- # Deep Scan Commands Scan everything: ```text /antidupe scan all ``` Player inventories: ```text /antidupe scan players ``` Ender Chests: ```text /antidupe scan ender ``` Loaded containers: ```text /antidupe scan containers ``` Current chunk: ```text /antidupe scan chunk ``` The full scan can check: - Online players - Ender Chests - Loaded containers - Inventory entities - Chest Minecarts - Hopper Minecarts - UUID registry - Ledger totals - Stack fingerprints --- # Automatic Chunk Scanning Whenever a chunk loads: 1. Anti-Dupe waits for the configured delay. 2. Supported inventory holders are scanned. Supported block inventories include: - Chest - Trapped Chest - Barrel - Shulker Box - Hopper - Furnace - Blast Furnace - Smoker - Brewing Stand - Crafter - Dropper - Dispenser Supported entities include: - Chest Minecart - Hopper Minecart - Inventory-holding entities --- # Transaction Ledger Anti-Dupe maintains a transaction ledger for legitimate item creation and movement. Examples include: - Mining - Crafting - Smelting - Trading - Trusted shop purchases - Authorized workstation transformations - Bundle transfers - Legitimate inventory movement Unauthorized increases continue through duplicate detection. The ledger does not automatically accept an unexplained quantity increase simply because the item exists. --- # Stack-Safe Accounting Stackable items retain normal vanilla behavior. Anti-Dupe uses: - Item fingerprints - Ledger totals - Transaction accounting - Cross-inventory quantity verification - Nested-container accounting where supported This allows ordinary stacks to split, merge, consolidate, enter bundles, and leave bundles without requiring every stack to contain a different UUID. --- # Unique Item Protection Items treated as unique can receive hidden UUID tracking. Tracked information can include: - UUID - Player - Inventory - Slot - Timestamp - Fingerprint When a duplicate UUID is confirmed: 1. Preserve the original. 2. Back up the duplicate. 3. Remove the duplicate. 4. Create a recovery entry. 5. Notify administrators. --- # Inventory Rollbacks Anti-Dupe 3.3 includes inventory rollback support. Snapshots can preserve player inventory state before sensitive operations or suspicious transactions. Snapshot information can include: - Main inventory - Hotbar - Armor - Offhand - Ender Chest - Player UUID - Server - World - Timestamp - Snapshot reason Rollback commands can include: ```text /antidupe rollback list [player] ``` ```text /antidupe rollback snapshot ``` ```text /antidupe rollback restore <id> [player] ``` Permission: ```text antidupe.rollback ``` --- # Safe Removal & Recovery Before an item is removed by Anti-Dupe, its complete ItemStack is backed up to: ```text plugins/Anti-Dupe/recovery.yml ``` Stored information can include: - Material - Amount - Name - Lore - Enchantments - Durability - Components - Persistent Data - Player - UUID - World - Coordinates - Detection Reason - Timestamp - Recovery ID - Restore Status If the recovery backup fails: - The item is NOT removed. - A severe error is logged. --- # Recovery Commands Recent recovery entries: ```text /antidupe recovery list ``` Lookup player: ```text /antidupe recovery player <player> ``` Restore original owner: ```text /antidupe recovery restore <id> ``` Restore to another player: ```text /antidupe recovery restore <id> <player> ``` Permission: ```text antidupe.recovery ``` --- # Database Support Anti-Dupe 3.3 supports: - SQLite - MySQL - MariaDB - PostgreSQL Database functionality can support: - Transaction ledger records - Network synchronization - Inventory state information - Virtual storage observations - Exploit information - Cross-server coordination - Storage fingerprints - Transfer state Example: ```yaml database: type: sqlite schema-migrations: true fail-startup-on-error: true sqlite: file: anti-dupe.db remote: host: 127.0.0.1 port: 3306 database: antidupe username: antidupe password: change-me ``` --- # Automatic Database Migration Anti-Dupe can automatically migrate its database schema as new data structures are introduced. This reduces the need for administrators to manually recreate databases during upgrades. Backups are still recommended before major database or plugin upgrades. --- # Velocity & Bungee Network Support Anti-Dupe 3.3 includes support for multi-server environments using Velocity or BungeeCord-style proxy networks. Network protection can coordinate: - Backend server IDs - Server heartbeats - Player transfer state - Transfer locks - Transfer snapshots - Shared ledger information - Cross-server UUID checks - Cross-server item accounting Example: ```yaml network: enabled: false proxy: VELOCITY server-id: survival-1 heartbeat-seconds: 30 stale-server-seconds: 120 transfer-lock-seconds: 20 join-verification-delay-ticks: 20 capture-transfer-snapshot: true shared-ledger: true cross-server-uuid-checks: true cross-server-stack-accounting: true ``` Every backend server should have a unique `server-id`. --- # Player Transfer Protection Cross-server movement can create an inventory synchronization window. Anti-Dupe can use: - Transfer snapshots - Transfer locks - Join verification - Shared ledger information - Cross-server UUID checks to help prevent items from existing simultaneously on multiple backend servers. --- # World-Aware Rules Different worlds can use different Anti-Dupe enforcement policies. Available policies include: ```text inherit disabled audit quarantine ``` Example: ```yaml world-rules: enabled: true default-mode: inherit worlds: world: mode: quarantine creative: mode: audit build_world: mode: disabled ``` This allows survival, creative, event, build, and administrative worlds to use different enforcement behavior. --- # Exploit Fingerprint Database Anti-Dupe 3.3 can classify suspicious behavior against known exploit patterns. Fingerprint categories can include: - Inventory rollback / stale-state replay - Hopper race conditions - Chunk unload/load duplication - Exact UUID cloning - Plugin transaction replay - Custom command transfer / identity-registration bypass - Plugin-managed vault quantity bypass - Repeated small-transfer threshold evasion - Stacked unique-item identity bypass Fingerprint results may include an estimated confidence level. These classifications are investigative indicators and are not absolute proof of which exploit was used. --- # OP Security Protection Anti-Dupe includes an optional strict OP authorization system. Only UUIDs explicitly listed in the security configuration may retain operator status. ```yaml security: enabled: false enforce-on-startup: true enforce-on-join: true enforce-on-world-change: true audit-period-seconds: 1 delayed-join-rechecks-ticks: - 1 - 20 - 100 notify-admins: true notify-permission: antidupe.notify op-protection: enabled: true allowed-uuids: [] block-player-op-commands: true recheck-after-server-commands: true ``` Protection includes: - Startup OP audit - Login OP verification - Delayed login rechecks - Periodic OP reconciliation - Player `/op` interception - `/minecraft:op` interception - `/bukkit:op` interception - Server-command rechecks - Removal of unauthorized OP status The periodic audit acts as a final reconciliation layer if another plugin grants OP directly. --- # In-Game OP Protection Management Authorized administrators can manage the OP protection UUID list without editing `config.yml`. Add a player: ```text /antidupe opprot add <player> ``` Remove a player: ```text /antidupe opprot remove <player> ``` List protected players: ```text /antidupe opprot list ``` When a player is added: 1. Anti-Dupe resolves the selected player's UUID. 2. The UUID is added to: ```yaml security: op-protection: allowed-uuids: - 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx' ``` 3. The updated list is saved to `config.yml`. Tab completion displays online players for `add`. For removal, Anti-Dupe can suggest known players already present in the protection list. --- # Creative Mode Protection Creative mode can optionally be restricted to explicitly authorized UUIDs. ```yaml security: creative-protection: enabled: true allowed-uuids: [] fallback-gamemode: SURVIVAL ``` Protection includes: - Blocking unauthorized Creative-mode changes - Login verification - Delayed login rechecks - World-change verification - Periodic reconciliation If an unauthorized player is found in Creative mode, Anti-Dupe can move them back to the configured fallback game mode. --- # In-Game Creative Protection Management Authorized administrators can manage the Creative protection list in game. Add: ```text /antidupe creativeprot add <player> ``` Remove: ```text /antidupe creativeprot remove <player> ``` List: ```text /antidupe creativeprot list ``` When added, the player's UUID is stored under: ```yaml security: creative-protection: allowed-uuids: - 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx' ``` The list is persisted directly to `config.yml`. --- # Security Management Permission Managing OP and Creative protection requires: ```text antidupe.security ``` This permission defaults to OP. Access to the main Anti-Dupe administrative command is also required. --- # ⚠️ Security Guard Setup Warning The master security system should remain disabled until legitimate administrator UUIDs are configured. ```yaml security: enabled: false ``` Before enabling: ```yaml security: enabled: true ``` make sure every legitimate administrator who requires OP or Creative access has been added to the appropriate UUID list. An enabled OP guard with an empty whitelist means: ```text NO PLAYER IS AUTHORIZED TO REMAIN OP ``` The OP/Creative security lists are separate from Anti-Dupe's normal duplication bypass whitelist. --- # Administrator Whitelist Anti-Dupe's normal administrator whitelist remains separate from OP and Creative protection. Add: ```text /antidupe whitelist add <player> ``` Remove: ```text /antidupe whitelist remove <player> ``` Check: ```text /antidupe whitelist check <player> ``` List: ```text /antidupe whitelist list ``` Stored in: ```text plugins/Anti-Dupe/admin-whitelist.yml ``` Permission: ```text antidupe.whitelist ``` --- # Administrator Test Command ```text /dupe ``` Duplicates the held item specifically for Anti-Dupe testing. The test is designed to exercise duplicate detection even when used by an administrator. Permission: ```text antidupe.dupe ``` --- # Console Verbosity Anti-Dupe includes configurable console logging levels. ```yaml warnings: console: true console-verbosity: low ``` Levels: | Level | Description | |------|-------------| | `off` | Suppress routine Anti-Dupe console output | | `low` | Startup and confirmed detections | | `med` | Scan summaries | | `high` | Diagnostics and testing information | Critical data-safety and recovery failures remain logged. Discord alerts, recovery records, daily logs, and administrator notifications are independent of console verbosity. --- # Private Detection Notifications Ordinary players do not receive duplicate-detection alerts. Notifications can be sent to: - Server Console - Authorized Administrators - Daily Log Files - Discord Permission: ```text antidupe.notify ``` --- # Daily Logs Location: ```text plugins/Anti-Dupe/logs/ ``` Format: ```text anti-dupe-YYYY-MM-DD.log ``` A new log is automatically used each day. --- # Discord Webhook Alerts Anti-Dupe supports asynchronous Discord webhook notifications. Detection embeds can contain: - Player - UUID - World - Coordinates - Detection Time - Detection Reason - Removed Item - Removed Quantity - Recovery ID Example: ```yaml discord: enabled: true webhook-url: "" username: "Anti-Dupe" avatar-url: "" locale: en_US embed-color: "#FFB000" include-coordinates: true role-mention: "" ``` Discord delivery runs asynchronously so webhook latency does not block the Minecraft server thread. --- # Multi-Language Support Supported locales: - de_DE - en_US - es_ES - fr_CA - fr_FR - it_IT - ja_JP - pl_PL - pt_BR - ru_RU - tr_TR - uk_UA - zh_CN Configuration: ```yaml language: default: en_US use-client-locale: true ``` Language files are stored in: ```text plugins/Anti-Dupe/lang/ ``` --- # Language File Migration Anti-Dupe can add newly introduced translation keys to existing language files without intentionally overwriting existing administrator customizations. The language files include a schema marker such as: ```yaml language-version: '3.3.1' ``` The language schema version is separate from the Anti-Dupe plugin version. --- # Language YAML Safety & Automatic Repair Anti-Dupe 3.3 includes additional protection against malformed language files. All bundled locale files use valid YAML structure. If an installed locale file becomes malformed, Anti-Dupe can: 1. Detect the YAML parsing failure. 2. Preserve the broken file as a backup. 3. Restore the bundled valid language file. 4. Continue loading the plugin. Example backup: ```text plugins/Anti-Dupe/lang/zh_CN.broken-20260808-121700.yml ``` This prevents a malformed translation from producing repeated startup parser errors or stopping the language system from loading correctly. --- # Bundled Administrator README Anti-Dupe includes administrator documentation inside the plugin resources: ```text src/main/resources/README.md ``` On first run, the README is copied to: ```text plugins/Anti-Dupe/README.md ``` This gives server administrators access to setup and command documentation without needing to open the source project or plugin JAR. The README includes information covering: - Installation - Anti-Dupe modes - Scanning - Recovery - Rollbacks - Trusted plugins - Security warning - OP protection - Creative protection - Security whitelist commands - Console verbosity - Database support - Network support - Discord - Permissions --- # bStats Metrics Anti-Dupe includes optional bStats integration. bStats Plugin ID: ```text 25245 ``` The bStats library remains separate from the Anti-Dupe version. Example dependency: ```gradle implementation 'org.bstats:bstats-bukkit:3.2.1' ``` Anti-Dupe itself remains: ```text 3.3 ``` Metrics can be controlled in configuration. Privacy-sensitive information such as player names, UUIDs, webhook URLs, inventory contents, recovery data, coordinates, and administrator whitelist entries should not be reported through metrics. --- # Permissions ```text antidupe.admin antidupe.notify antidupe.whitelist antidupe.recovery antidupe.rollback antidupe.security antidupe.dupe antidupe.bypass ``` --- # Main Administrative Commands ```text /antidupe ``` Scanning: ```text /antidupe scan all /antidupe scan players /antidupe scan ender /antidupe scan containers /antidupe scan chunk ``` Recovery: ```text /antidupe recovery list /antidupe recovery player <player> /antidupe recovery restore <id> /antidupe recovery restore <id> <player> ``` Rollback: ```text /antidupe rollback list [player] /antidupe rollback snapshot /antidupe rollback restore <id> [player] ``` Administrator whitelist: ```text /antidupe whitelist add <player> /antidupe whitelist remove <player> /antidupe whitelist check <player> /antidupe whitelist list ``` OP protection: ```text /antidupe opprot add <player> /antidupe opprot remove <player> /antidupe opprot list ``` Creative protection: ```text /antidupe creativeprot add <player> /antidupe creativeprot remove <player> /antidupe creativeprot list ``` Console verbosity: ```text /antidupe verbosity off /antidupe verbosity low /antidupe verbosity med /antidupe verbosity high ``` Testing: ```text /dupe ``` --- # Recommended Deployment Begin with: ```yaml mode: AUDIT ``` Test normal server mechanics including: - Player Crafting - Crafting Tables - Anvils - Smithing Tables - Grindstones - Stonecutters - Cartography Tables - Looms - Furnaces - Blast Furnaces - Smokers - Brewing Stands - Villager Trading - Crafters - Bundles - Nested bundle contents - Shops - Hoppers - Ender Chests - Shulker Boxes - Stack Splitting - Stack Merging - Custom Commands - Private Vaults - Modded/Plugin Containers - Cross-server Transfers Also test every plugin that can: - Create items - Delete items - Transfer items - Modify inventories - Restore inventories - Store inventories externally - Create custom GUIs - Modify bundles - Grant Creative mode - Modify OP state Once normal server behavior has been validated: ```yaml mode: QUARANTINE ``` Quarantine mode follows the core safety sequence: 1. Preserve the legitimate/original item when it can be identified. 2. Back up the suspected duplicate. 3. Remove the confirmed excess. 4. Record the incident. 5. Notify administrators. 6. Send configured Discord alerts. 7. Allow administrator recovery. --- # Anti-Dupe 3.3 Anti-Dupe 3.3 expands the original 3.2 protection model with: - Vanilla-aware transaction handling - Crafting false-positive prevention - Dedicated workstation protection - Bundle-aware transaction accounting - Recursive nested bundle scanning - Custom command transfer monitoring - Plugin-managed vault monitoring - Small-transfer pattern detection - Identity-integrity protection - Inventory rollback support - Multiple database backends - Automatic database migrations - Velocity/Bungee network coordination - Cross-server transfer protection - World-aware enforcement - Exploit fingerprint classification - OP authorization protection - Creative-mode authorization protection - In-game OP whitelist management - In-game Creative whitelist management - Security UUID persistence - Security-management permissions - Bundled administrator documentation - Updated language infrastructure - Automatic language-file migration - Malformed YAML detection and recovery - bStats integration - Discord alerts - Daily logging - Safe duplicate recovery