Merge branch '1.20.3-multiloader' into 1.20.2-multiloader

# Conflicts:
#	gradle.properties

.github/workflows/release.yml

@@ -1,8 +1,5 @@
 name: release
 on:
-    push:
-        tags:
-            - "v**"
     workflow_dispatch:
 
 jobs:

CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.2.0] - 2024-11-28
+### Added
+- Added support for [SkinShuffle](https://modrinth.com/mod/skinshuffle) clients (requires FabricAPI on Fabric)
+  (closes [#34](https://github.com/Suiranoil/SkinRestorer/issues/34))
+- Added `providers.mineskin.apiKey` config option (see [wiki](https://github.com/Suiranoil/SkinRestorer/wiki/Configuration#providersmineskin))
+### Changed
+- Migrated to MineSkin's new API V2
+### Fixed
+- Fixed `providers` config validation
+### Removed
+- Dropped support for NeoForge on Minecraft 1.20.2-1.20.4
+
 ## [2.1.0] - 2024-09-26
 ### Added
 - Added `config reload` command for dynamic configuration updates

CHANGELOG_LATEST.md

@@ -1,9 +1,10 @@
 ### Added
-- Added `config reload` command for dynamic configuration updates
+- Added support for [SkinShuffle](https://modrinth.com/mod/skinshuffle) clients (requires FabricAPI on Fabric)
-- Added `refreshSkinOnJoin` config option (see [wiki](https://github.com/Suiranoil/SkinRestorer/wiki/Configuration#refreshskinonjoin))
+  (closes [#34](https://github.com/Suiranoil/SkinRestorer/issues/34))
-- Implemented caching for skin providers
+- Added `providers.mineskin.apiKey` config option (see [wiki](https://github.com/Suiranoil/SkinRestorer/wiki/Configuration#providersmineskin))
-- Added provider configurations (see [wiki](https://github.com/Suiranoil/SkinRestorer/wiki/Configuration#providers))
+### Changed
-- Added username and url validation for requests
+- Migrated to MineSkin's new API V2
 ### Fixed
-- Fixed old skin directory migration not working
+- Fixed `providers` config validation
-- Prevented overwriting existing skin files during migration
+### Removed
+- Dropped support for NeoForge on Minecraft 1.20.2-1.20.4

README.md

@@ -9,26 +9,34 @@ A server-side mod for managing and restoring player skins.
 
 - **Set skins from Mojang Account**: Fetch and apply skins using a valid Minecraft username.
 - **Set skins from Ely.by**: Fetch and apply skins using a valid [Ely.by](https://ely.by/) username.
-- **Set skins from URL**: Fetch and apply skins from any image URL, supporting both classic (Steve) and slim (Alex) skin models.
+- **Set skins from URL**: Fetch and apply skins from any image URL, supporting both classic (Steve) and slim (Alex) skin
-- **Automatic skin fetching**: Automatically fetch skin from Mojang/Ely.by when a player joins the server running in offline/insecure mode ([configurable](https://github.com/Suiranoil/SkinRestorer/wiki/Configuration)).
+  models.
+- **Automatic skin fetching**: Automatically fetch skin from Mojang/Ely.by when a player joins the server running in
+  offline/insecure mode ([configurable](https://github.com/Suiranoil/SkinRestorer/wiki/Configuration)).
 - **Singleplayer support**: Apply skins individually for each world.
 - **Permissions API support**
+- **SkinShuffle support**: Allow players with [SkinShuffle](https://modrinth.com/mod/skinshuffle) installed to apply skins using GUI.
 
 ## 📜 Command Usage Guide
 
-For a detailed list of available commands and their usage, please visit the [commands wiki page](https://github.com/Suiranoil/SkinRestorer/wiki/Commands).
+For a detailed list of available commands and their usage, please visit
+the [commands wiki page](https://github.com/Suiranoil/SkinRestorer/wiki/Commands).
 
 ## ❌ Known Incompatibilities
 
-- **[Arclight](https://github.com/IzzelAliz/Arclight) (<=1.20.1)**: Trials or older versions are not compatible due to mixin conflicts.
+- **[Arclight](https://github.com/IzzelAliz/Arclight) (<=1.20.1)**: Trials or older versions are not compatible due to
+  mixin conflicts.
   As an alternative, consider using the [SkinsRestorer](https://www.spigotmc.org/resources/skinsrestorer.2124/) plugin.
 
 ## 🪙 Donation
 
-If you enjoy using **SkinRestorer** and would like to support its development, you can contribute through cryptocurrency donations.
+If you enjoy using **SkinRestorer** and would like to support its development, you can contribute through the following
+platforms:
 
-Bitcoin (BTC): `1Ndbwny8pxdnWXFgadp95fp97y5JqMJKTX`\
+[![Ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/lionarius)
-USDT (TRC20): `TGXn8wrqku5KLzwPWQAeH7wgnV4UzwHEae`\
+
+Bitcoin (BTC): `1Ndbwny8pxdnWXFgadp95fp97y5JqMJKTX`  
+USDT (TRC20): `TGXn8wrqku5KLzwPWQAeH7wgnV4UzwHEae`  
 USDT (TON): `UQAQF18Xlmx-V1oZ90C2YOju5qI7q1LgrCP5QaIUhqIELmDS`
 
 Thank you for your generosity!

build.gradle

@@ -1,13 +1,29 @@
 plugins {
     // see https://fabricmc.net/develop/ for new versions
-    id 'fabric-loom' version '1.7-SNAPSHOT' apply false
+    id 'fabric-loom' version '1.8-SNAPSHOT' apply false
     // see https://projects.neoforged.net/neoforged/neogradle for new versions
     id 'net.neoforged.gradle.userdev' version '7.0.153' apply false
     // see https://files.minecraftforge.net/net/minecraftforge/gradle/ForgeGradle/ for new versions
-    id 'net.minecraftforge.gradle' version '6.0.26' apply false
+    id 'net.minecraftforge.gradle' version '6.0.29' apply false
     id 'org.parchmentmc.librarian.forgegradle' version '1.+' apply false
 
     id 'org.spongepowered.mixin' version '0.7-SNAPSHOT' apply false
 
-    id 'me.modmuss50.mod-publish-plugin' version '0.6.3' apply false
+    id 'me.modmuss50.mod-publish-plugin' version '0.8.1' apply false
+}
+
+allprojects {
+    repositories {
+        exclusiveContent {
+            forRepository {
+                maven {
+                    name = 'lionarius-repository'
+                    url = 'https://reposilite.lionarius.ru/releases'
+                }
+            }
+            filter {
+                includeGroupAndSubgroups('org.mineskin')
+            }
+        }
+    }
 }

buildSrc/src/main/groovy/multiloader-loader.gradle

@@ -3,10 +3,10 @@ plugins {
 }
 
 configurations {
-    commonJava{
+    commonJava {
         canBeResolved = true
     }
-    commonResources{
+    commonResources {
         canBeResolved = true
     }
 }

buildSrc/src/main/groovy/multiloader-publish.gradle

@@ -6,7 +6,7 @@ publishMods {
     if (project.name == 'fabric')
         file = remapJar.archiveFile
     else
-        file = jar.archiveFile
+        file = tasks.named('jarJar').get().archiveFile
 
     modLoaders.add(project.name)
     type = STABLE
@@ -22,6 +22,9 @@ publishMods {
 
         minecraftVersions.addAll(minecraft_version_list.split(','))
         serverRequired = true
+
+        if (project.name == 'fabric')
+            optional(fabric_optional_dependencies.split(','))
     }
 
     modrinth {
@@ -31,5 +34,8 @@ publishMods {
         accessToken = providers.environmentVariable("MODRINTH_TOKEN")
 
         minecraftVersions.addAll(minecraft_version_list.split(','))
+
+        if (project.name == 'fabric')
+            optional(fabric_optional_dependencies.split(','))
     }
 }

common/build.gradle

@@ -1,6 +1,6 @@
 plugins {
     id 'multiloader-common'
-    
+
     id 'fabric-loom'
 }
 
@@ -11,6 +11,8 @@ dependencies {
         parchment("org.parchmentmc.data:parchment-${parchment_minecraft}:${parchment_version}@zip")
     }
     compileOnly group: 'org.spongepowered', name: 'mixin', version: '0.8.5'
+
+    implementation("org.mineskin:java-client:${mineskin_client_version}")
 }
 
 loom {
@@ -18,7 +20,7 @@ loom {
     if (aw.exists()) {
         accessWidenerPath.set(aw)
     }
-    
+
     mixin {
         useLegacyMixinAp = false
     }

common/gradle.properties

@@ -1 +1 @@
-fabric.loom.dontRemap = true
+fabric.loom.dontRemap=true

common/src/main/java/net/lionarius/skinrestorer/SkinRestorer.java

@@ -1,8 +1,10 @@
 package net.lionarius.skinrestorer;
 
 import com.mojang.authlib.GameProfile;
-import net.lionarius.skinrestorer.config.BuiltInProviderConfig;
+import com.mojang.brigadier.CommandDispatcher;
+import net.lionarius.skinrestorer.command.SkinCommand;
 import net.lionarius.skinrestorer.config.Config;
+import net.lionarius.skinrestorer.config.provider.BuiltInProviderConfig;
 import net.lionarius.skinrestorer.platform.Services;
 import net.lionarius.skinrestorer.skin.SkinIO;
 import net.lionarius.skinrestorer.skin.SkinStorage;
@@ -13,6 +15,8 @@ import net.lionarius.skinrestorer.util.FileUtils;
 import net.lionarius.skinrestorer.util.PlayerUtils;
 import net.lionarius.skinrestorer.util.Result;
 import net.lionarius.skinrestorer.util.WebUtils;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.level.storage.LevelResource;
@@ -20,7 +24,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.nio.file.Path;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Optional;
@@ -57,11 +60,20 @@ public final class SkinRestorer {
         return Optional.ofNullable(SkinRestorer.providersRegistry.get(name));
     }
     
+    public static ResourceLocation resourceLocation(String name) {
+        return new ResourceLocation(SkinRestorer.MOD_ID, name);
+    }
+    
+    public static String assetPath(String name) {
+        return String.format("/assets/%s/%s", SkinRestorer.MOD_ID, name);
+    }
+    
     public static void onInitialize() {
         SkinRestorer.configDir = Services.PLATFORM.getConfigDirectory().resolve(SkinRestorer.MOD_ID);
         SkinRestorer.reloadConfig();
         
         SkinRestorer.providersRegistry.register(EmptySkinProvider.PROVIDER_NAME, SkinProvider.EMPTY, false);
+        SkinRestorer.providersRegistry.register(SkinShuffleSkinProvider.PROVIDER_NAME, SkinProvider.SKIN_SHUFFLE, false);
         
         SkinRestorer.registerDefaultSkinProvider(MojangSkinProvider.PROVIDER_NAME, SkinProvider.MOJANG, SkinRestorer.getConfig().providersConfig().mojang());
         SkinRestorer.registerDefaultSkinProvider(ElyBySkinProvider.PROVIDER_NAME, SkinProvider.ELY_BY, SkinRestorer.getConfig().providersConfig().ely_by());
@@ -72,29 +84,18 @@ public final class SkinRestorer {
         var isDefaultName = config.name().equals(defaultName);
         SkinRestorer.providersRegistry.register(defaultName, provider, config.enabled() && isDefaultName);
         
-        if (!isDefaultName && Arrays.stream(SkinProvider.BUILTIN_PROVIDER_NAMES).noneMatch(name -> name.equals(config.name())))
+        if (!isDefaultName && !SkinProvider.BUILTIN_PROVIDER_NAMES.contains(config.name()))
             SkinRestorer.providersRegistry.register(config.name(), provider, config.enabled());
     }
     
-    public static void onServerStarted(MinecraftServer server) {
-        Path worldSkinDirectory = server.getWorldPath(LevelResource.ROOT).resolve(SkinRestorer.MOD_ID);
-        FileUtils.tryMigrateOldSkinDirectory(SkinRestorer.getConfigDir(), worldSkinDirectory);
-        
-        SkinRestorer.skinStorage = new SkinStorage(new SkinIO(worldSkinDirectory));
-    }
-    
     public static void reloadConfig() {
         SkinRestorer.config = Config.load(SkinRestorer.getConfigDir());
         Translation.reloadTranslations();
         WebUtils.recreateHttpClient();
         
-        MojangSkinProvider.createCache();
+        MojangSkinProvider.reload();
-        ElyBySkinProvider.createCache();
+        ElyBySkinProvider.reload();
-        MineskinSkinProvider.createCache();
+        MineskinSkinProvider.reload();
-    }
-    
-    public static String assetPath(String name) {
-        return String.format("/assets/%s/%s", SkinRestorer.MOD_ID, name);
     }
     
     public static Collection<ServerPlayer> applySkin(MinecraftServer server, Iterable<GameProfile> targets, SkinValue value, boolean save) {
@@ -104,12 +105,12 @@ public final class SkinRestorer {
             if (!SkinRestorer.getSkinStorage().hasSavedSkin(profile.getId()))
                 value = value.setOriginalValue(PlayerUtils.getPlayerSkin(profile));
             
-            if (save)
-                SkinRestorer.getSkinStorage().setSkin(profile.getId(), value);
-            
             if (PlayerUtils.areSkinPropertiesEquals(value.value(), PlayerUtils.getPlayerSkin(profile)))
                 continue;
             
+            if (save)
+                SkinRestorer.getSkinStorage().setSkin(profile.getId(), value);
+            
             PlayerUtils.applyRestoredSkin(profile, value.value());
             
             var player = server.getPlayerList().getPlayer(profile.getId());
@@ -155,4 +156,23 @@ public final class SkinRestorer {
                     return Result.error(e.getMessage());
                 });
     }
+    
+    public static class Events {
+        private Events() {}
+        
+        public static void onServerStarted(MinecraftServer server) {
+            Path worldSkinDirectory = server.getWorldPath(LevelResource.ROOT).resolve(SkinRestorer.MOD_ID);
+            FileUtils.tryMigrateOldSkinDirectory(SkinRestorer.getConfigDir(), worldSkinDirectory);
+            
+            SkinRestorer.skinStorage = new SkinStorage(new SkinIO(worldSkinDirectory));
+        }
+        
+        public static void onCommandRegister(CommandDispatcher<CommandSourceStack> dispatcher) {
+            SkinCommand.register(dispatcher);
+        }
+        
+        public static void onPlayerDisconnect(ServerPlayer player) {
+            SkinRestorer.getSkinStorage().removeSkin(player.getUUID());
+        }
+    }
 }

common/src/main/java/net/lionarius/skinrestorer/compat/skinshuffle/SkinShuffleCompatibility.java

@@ -0,0 +1,55 @@
+package net.lionarius.skinrestorer.compat.skinshuffle;
+
+import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.platform.Services;
+import net.lionarius.skinrestorer.skin.SkinValue;
+import net.lionarius.skinrestorer.skin.provider.SkinShuffleSkinProvider;
+import net.lionarius.skinrestorer.util.PlayerUtils;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+
+import java.util.Collections;
+
+public class SkinShuffleCompatibility {
+    
+    public static final String MOD_ID = "skinshuffle";
+    
+    private static final boolean SHOULD_APPLY = !Services.PLATFORM.isModLoaded(SkinShuffleCompatibility.MOD_ID);
+    
+    private SkinShuffleCompatibility() {}
+    
+    public static boolean shouldApply() {
+        return SkinShuffleCompatibility.SHOULD_APPLY;
+    }
+    
+    public static ResourceLocation resourceLocation(String name) {
+        return new ResourceLocation(SkinShuffleCompatibility.MOD_ID, name);
+    }
+    
+    public static void onPlayerJoin(ServerPlayer player) {
+        Services.COMPATIBILITY.skinShuffle_sendHandshake(player);
+    }
+    
+    public static void handleSkinRefresh(MinecraftServer server, ServerPlayer player, SkinShuffleSkinRefreshPayload payload) {
+        var property = payload.textureProperty();
+        
+        if (!property.name().equals(PlayerUtils.TEXTURES_KEY))
+            return;
+        
+        if (!property.hasSignature())
+            return;
+        
+        server.execute(() -> {
+            SkinRestorer.applySkin(
+                    server,
+                    Collections.singleton(player.getGameProfile()),
+                    new SkinValue(SkinShuffleSkinProvider.PROVIDER_NAME, null, null, property),
+                    !server.usesAuthentication()
+            );
+            
+            if (server.usesAuthentication() && SkinRestorer.getSkinStorage().hasSavedSkin(player.getUUID()))
+                SkinRestorer.getSkinStorage().deleteSkin(player.getUUID());
+        });
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/compat/skinshuffle/SkinShuffleHandshakePayload.java

@@ -0,0 +1,23 @@
+package net.lionarius.skinrestorer.compat.skinshuffle;
+
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.NotNull;
+
+public record SkinShuffleHandshakePayload() implements CustomPacketPayload {
+
+    public static final SkinShuffleHandshakePayload INSTANCE = new SkinShuffleHandshakePayload();
+
+    public static final ResourceLocation PACKET_ID = SkinShuffleCompatibility.resourceLocation("handshake");
+
+    @Override
+    public void write(@NotNull FriendlyByteBuf buf) {
+        // NO-OP
+    }
+    
+    @Override
+    public @NotNull ResourceLocation id() {
+        return PACKET_ID;
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/compat/skinshuffle/SkinShuffleSkinRefreshPayload.java

@@ -0,0 +1,7 @@
+package net.lionarius.skinrestorer.compat.skinshuffle;
+
+import com.mojang.authlib.properties.Property;
+
+public interface SkinShuffleSkinRefreshPayload {
+    Property textureProperty();
+}

common/src/main/java/net/lionarius/skinrestorer/compat/skinshuffle/SkinShuffleSkinRefreshV1Payload.java

@@ -0,0 +1,35 @@
+package net.lionarius.skinrestorer.compat.skinshuffle;
+
+import com.mojang.authlib.properties.Property;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.NotNull;
+
+public record SkinShuffleSkinRefreshV1Payload(
+        Property textureProperty) implements CustomPacketPayload, SkinShuffleSkinRefreshPayload {
+    
+    public static final ResourceLocation PACKET_ID = SkinShuffleCompatibility.resourceLocation("refresh");
+    
+    public static void encode(FriendlyByteBuf buf, SkinShuffleSkinRefreshV1Payload value) {
+        var textureProperty = value.textureProperty();
+        
+        buf.writeUtf(textureProperty.name());
+        buf.writeUtf(textureProperty.value());
+        buf.writeNullable(textureProperty.signature(), FriendlyByteBuf::writeUtf);
+    }
+    
+    public static SkinShuffleSkinRefreshV1Payload decode(FriendlyByteBuf buf) {
+        return new SkinShuffleSkinRefreshV1Payload(new Property(buf.readUtf(), buf.readUtf(), buf.readNullable(FriendlyByteBuf::readUtf)));
+    }
+    
+    @Override
+    public void write(@NotNull FriendlyByteBuf buf) {
+        encode(buf, this);
+    }
+    
+    @Override
+    public @NotNull ResourceLocation id() {
+        return PACKET_ID;
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/compat/skinshuffle/SkinShuffleSkinRefreshV2Payload.java

@@ -0,0 +1,43 @@
+package net.lionarius.skinrestorer.compat.skinshuffle;
+
+import com.mojang.authlib.properties.Property;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.NotNull;
+
+public record SkinShuffleSkinRefreshV2Payload(
+        Property textureProperty) implements CustomPacketPayload, SkinShuffleSkinRefreshPayload {
+    
+    public static final ResourceLocation PACKET_ID = SkinShuffleCompatibility.resourceLocation("skin_refresh");
+
+    public static void encode(FriendlyByteBuf buf, SkinShuffleSkinRefreshV2Payload value) {
+        var textureProperty = value.textureProperty();
+        
+        buf.writeBoolean(textureProperty.hasSignature());
+        buf.writeUtf(textureProperty.name());
+        buf.writeUtf(textureProperty.value());
+        if (textureProperty.hasSignature()) {
+            assert textureProperty.signature() != null;
+            
+            buf.writeUtf(textureProperty.signature());
+        }
+    }
+
+    public static SkinShuffleSkinRefreshV2Payload decode(FriendlyByteBuf buf) {
+        if (buf.readBoolean()) {
+            return new SkinShuffleSkinRefreshV2Payload(new Property(buf.readUtf(), buf.readUtf(), buf.readUtf()));
+        }
+        return new SkinShuffleSkinRefreshV2Payload(new Property(buf.readUtf(), buf.readUtf(), null));
+    }
+    
+    @Override
+    public void write(@NotNull FriendlyByteBuf buf) {
+        encode(buf, this);
+    }
+    
+    @Override
+    public @NotNull ResourceLocation id() {
+        return PACKET_ID;
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/config/BuiltInProviderConfig.java

@@ -1,7 +0,0 @@
-package net.lionarius.skinrestorer.config;
-
-public record BuiltInProviderConfig(boolean enabled, String name, CacheConfig cache) {
-    public boolean isValid() {
-        return this.name != null && this.cache != null && !this.name.isEmpty() && this.cache.isValid();
-    }
-}

common/src/main/java/net/lionarius/skinrestorer/config/CacheConfig.java

@@ -1,7 +0,0 @@
-package net.lionarius.skinrestorer.config;
-
-public record CacheConfig(boolean enabled, long duration) {
-    public boolean isValid() {
-        return this.duration > 0;
-    }
-}

common/src/main/java/net/lionarius/skinrestorer/config/Config.java

@@ -1,13 +1,15 @@
 package net.lionarius.skinrestorer.config;
 
 import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.config.provider.ProvidersConfig;
 import net.lionarius.skinrestorer.util.FileUtils;
 import net.lionarius.skinrestorer.util.JsonUtils;
+import net.lionarius.skinrestorer.util.gson.GsonPostProcessable;
 
 import java.nio.file.Path;
 import java.util.Optional;
 
-public final class Config {
+public final class Config implements GsonPostProcessable {
     
     public static final String CONFIG_FILENAME = "config.json";
     
@@ -68,14 +70,13 @@ public final class Config {
         if (config == null)
             config = new Config();
         
-        config.verifyAndFix();
-        
         FileUtils.writeFile(path.resolve(Config.CONFIG_FILENAME), JsonUtils.toJson(config));
         
         return config;
     }
     
-    private void verifyAndFix() {
+    @Override
+    public void gsonPostProcess() {
         if (this.language == null || this.language.isEmpty()) {
             SkinRestorer.LOGGER.warn("Language config is null or empty, defaulting to 'en_us'");
             this.language = "en_us";
@@ -95,7 +96,7 @@ public final class Config {
             try {
                 this.parsedProxy = Proxy.parse(this.proxy);
             } catch (Exception e) {
-                SkinRestorer.LOGGER.warn("Could not parse proxy config", e);
+                SkinRestorer.LOGGER.warn("Could not parse proxy config: {}", e.getMessage());
                 this.parsedProxy = null;
             }
         }
@@ -109,8 +110,5 @@ public final class Config {
             SkinRestorer.LOGGER.warn("Providers config is null, using default");
             this.providers = ProvidersConfig.DEFAULT;
         }
-        
-        if (!this.providers.isValid())
-            this.providers.fix();
     }
 }

common/src/main/java/net/lionarius/skinrestorer/config/ProvidersConfig.java

@@ -1,65 +0,0 @@
-package net.lionarius.skinrestorer.config;
-
-import net.lionarius.skinrestorer.SkinRestorer;
-import net.lionarius.skinrestorer.skin.provider.ElyBySkinProvider;
-import net.lionarius.skinrestorer.skin.provider.MineskinSkinProvider;
-import net.lionarius.skinrestorer.skin.provider.MojangSkinProvider;
-
-public final class ProvidersConfig {
-    public static final ProvidersConfig DEFAULT = new ProvidersConfig(
-            new BuiltInProviderConfig(true, MojangSkinProvider.PROVIDER_NAME, new CacheConfig(true, 60)),
-            new BuiltInProviderConfig(true, ElyBySkinProvider.PROVIDER_NAME, new CacheConfig(true, 60)),
-            new BuiltInProviderConfig(true, MineskinSkinProvider.PROVIDER_NAME, new CacheConfig(true, 300))
-    );
-    
-    private BuiltInProviderConfig mojang;
-    private BuiltInProviderConfig ely_by;
-    private BuiltInProviderConfig mineskin;
-    
-    public ProvidersConfig(BuiltInProviderConfig mojang, BuiltInProviderConfig ely_by, BuiltInProviderConfig mineskin) {
-        this.mojang = mojang;
-        this.ely_by = ely_by;
-        this.mineskin = mineskin;
-    }
-    
-    public boolean isValid() {
-        if (this == ProvidersConfig.DEFAULT)
-            return true;
-        
-        return this.mojang == null || !this.mojang.isValid()
-               || this.ely_by == null || !this.ely_by.isValid()
-               || this.mineskin == null || !this.mineskin.isValid();
-    }
-    
-    public void fix() {
-        if (this == ProvidersConfig.DEFAULT)
-            return;
-        
-        if (this.mojang == null || !this.mojang.isValid()) {
-            SkinRestorer.LOGGER.warn("Mojang provider config is invalid, using default");
-            this.mojang = ProvidersConfig.DEFAULT.mojang();
-        }
-        
-        if (this.ely_by == null || !this.ely_by.isValid()) {
-            SkinRestorer.LOGGER.warn("Ely.By provider config is invalid, using default");
-            this.ely_by = ProvidersConfig.DEFAULT.ely_by();
-        }
-        
-        if (this.mineskin == null || !this.mineskin.isValid()) {
-            SkinRestorer.LOGGER.warn("Mineskin provider config is invalid, using default");
-            this.mineskin = ProvidersConfig.DEFAULT.mineskin();
-        }
-    }
-    
-    public BuiltInProviderConfig mojang() {
-        return this.mojang;
-    }
-    
-    public BuiltInProviderConfig ely_by() {
-        return this.ely_by;
-    }
-    
-    public BuiltInProviderConfig mineskin() {
-        return this.mineskin;
-    }
-}

common/src/main/java/net/lionarius/skinrestorer/config/provider/BuiltInProviderConfig.java

@@ -0,0 +1,10 @@
+package net.lionarius.skinrestorer.config.provider;
+
+public interface BuiltInProviderConfig {
+
+    boolean enabled();
+
+    String name();
+
+    CacheConfig cache();
+}

common/src/main/java/net/lionarius/skinrestorer/config/provider/CacheConfig.java

@@ -0,0 +1,28 @@
+package net.lionarius.skinrestorer.config.provider;
+
+import net.lionarius.skinrestorer.SkinRestorer;
+
+public final class CacheConfig {
+    private boolean enabled;
+    private long duration;
+
+    public CacheConfig(boolean enabled, long duration) {
+        this.enabled = enabled;
+        this.duration = duration;
+    }
+
+    public boolean enabled() {
+        return enabled;
+    }
+
+    public long duration() {
+        return duration;
+    }
+
+    void validate(CacheConfig defaultValue) {
+        if (this.duration <= 0) {
+            SkinRestorer.LOGGER.warn("Cache duration is less than or equal to zero, defaulting to {}", defaultValue.duration());
+            this.duration = defaultValue.duration();
+        }
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/config/provider/ElyByProviderConfig.java

@@ -0,0 +1,46 @@
+package net.lionarius.skinrestorer.config.provider;
+
+import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.skin.provider.ElyBySkinProvider;
+import net.lionarius.skinrestorer.util.gson.GsonPostProcessable;
+
+public class ElyByProviderConfig implements BuiltInProviderConfig, GsonPostProcessable {
+    private static final CacheConfig DEFAULT_CACHE_VALUE = new CacheConfig(true, 60);
+    
+    private boolean enabled;
+    private String name;
+    private CacheConfig cache;
+    
+    public ElyByProviderConfig() {
+        this.enabled = true;
+        this.name = ElyBySkinProvider.PROVIDER_NAME;
+        this.cache = DEFAULT_CACHE_VALUE;
+    }
+    
+    public boolean enabled() {
+        return enabled;
+    }
+    
+    public String name() {
+        return name;
+    }
+    
+    public CacheConfig cache() {
+        return cache;
+    }
+    
+    @Override
+    public void gsonPostProcess() {
+        if (this.name == null || this.name.isEmpty()) {
+            SkinRestorer.LOGGER.warn("Ely.By provider name is null or empty, defaulting to '{}'", ElyBySkinProvider.PROVIDER_NAME);
+            this.name = ElyBySkinProvider.PROVIDER_NAME;
+        }
+        
+        if (this.cache == null) {
+            SkinRestorer.LOGGER.warn("Ely.By provider cache is null, using default");
+            this.cache = DEFAULT_CACHE_VALUE;
+        } else {
+            this.cache.validate(DEFAULT_CACHE_VALUE);
+        }
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/config/provider/MineskinProviderConfig.java

@@ -0,0 +1,57 @@
+package net.lionarius.skinrestorer.config.provider;
+
+import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.skin.provider.MineskinSkinProvider;
+import net.lionarius.skinrestorer.util.gson.GsonPostProcessable;
+
+public class MineskinProviderConfig implements BuiltInProviderConfig, GsonPostProcessable {
+    private static final CacheConfig DEFAULT_CACHE_VALUE = new CacheConfig(true, 300);
+    
+    private boolean enabled;
+    private String name;
+    private CacheConfig cache;
+    private String apiKey;
+    
+    public MineskinProviderConfig() {
+        this.enabled = true;
+        this.name = MineskinSkinProvider.PROVIDER_NAME;
+        this.cache = DEFAULT_CACHE_VALUE;
+        this.apiKey = "";
+    }
+    
+    public boolean enabled() {
+        return enabled;
+    }
+    
+    public String name() {
+        return name;
+    }
+    
+    public CacheConfig cache() {
+        return cache;
+    }
+    
+    public String apiKey() {
+        return apiKey;
+    }
+    
+    @Override
+    public void gsonPostProcess() {
+        if (this.name == null || this.name.isEmpty()) {
+            SkinRestorer.LOGGER.warn("Mineskin provider name is null or empty, defaulting to '{}'", MineskinSkinProvider.PROVIDER_NAME);
+            this.name = MineskinSkinProvider.PROVIDER_NAME;
+        }
+        
+        if (this.cache == null) {
+            SkinRestorer.LOGGER.warn("Mineskin cache is null, using default");
+            this.cache = DEFAULT_CACHE_VALUE;
+        } else {
+            this.cache.validate(DEFAULT_CACHE_VALUE);
+        }
+        
+        if (this.apiKey == null) {
+            SkinRestorer.LOGGER.warn("Mineskin API key is null, defaulting to an empty string");
+            this.apiKey = "";
+        }
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/config/provider/MojangProviderConfig.java

@@ -0,0 +1,46 @@
+package net.lionarius.skinrestorer.config.provider;
+
+import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.skin.provider.MojangSkinProvider;
+import net.lionarius.skinrestorer.util.gson.GsonPostProcessable;
+
+public class MojangProviderConfig implements BuiltInProviderConfig, GsonPostProcessable {
+    private static final CacheConfig DEFAULT_CACHE_VALUE = new CacheConfig(true, 60);
+    
+    private boolean enabled;
+    private String name;
+    private CacheConfig cache;
+    
+    public MojangProviderConfig() {
+        this.enabled = true;
+        this.name = MojangSkinProvider.PROVIDER_NAME;
+        this.cache = DEFAULT_CACHE_VALUE;
+    }
+    
+    public boolean enabled() {
+        return enabled;
+    }
+    
+    public String name() {
+        return name;
+    }
+    
+    public CacheConfig cache() {
+        return cache;
+    }
+    
+    @Override
+    public void gsonPostProcess() {
+        if (this.name == null || this.name.isEmpty()) {
+            SkinRestorer.LOGGER.warn("Mojang provider name is null or empty, defaulting to '{}'", MojangSkinProvider.PROVIDER_NAME);
+            this.name = MojangSkinProvider.PROVIDER_NAME;
+        }
+        
+        if (this.cache == null) {
+            SkinRestorer.LOGGER.warn("Mojang provider cache is null, using default");
+            this.cache = DEFAULT_CACHE_VALUE;
+        } else {
+            this.cache.validate(DEFAULT_CACHE_VALUE);
+        }
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/config/provider/ProvidersConfig.java

@@ -0,0 +1,52 @@
+package net.lionarius.skinrestorer.config.provider;
+
+import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.util.gson.GsonPostProcessable;
+
+public final class ProvidersConfig implements GsonPostProcessable {
+    public static final ProvidersConfig DEFAULT = new ProvidersConfig(
+            new MojangProviderConfig(),
+            new ElyByProviderConfig(),
+            new MineskinProviderConfig()
+    );
+
+    private MojangProviderConfig mojang;
+    private ElyByProviderConfig ely_by;
+    private MineskinProviderConfig mineskin;
+
+    public ProvidersConfig(MojangProviderConfig mojang, ElyByProviderConfig ely_by, MineskinProviderConfig mineskin) {
+        this.mojang = mojang;
+        this.ely_by = ely_by;
+        this.mineskin = mineskin;
+    }
+
+    public MojangProviderConfig mojang() {
+        return this.mojang;
+    }
+
+    public ElyByProviderConfig ely_by() {
+        return this.ely_by;
+    }
+
+    public MineskinProviderConfig mineskin() {
+        return this.mineskin;
+    }
+
+    @Override
+    public void gsonPostProcess() {
+        if (this.mojang == null) {
+            SkinRestorer.LOGGER.warn("Mojang provider config is null, using default");
+            this.mojang = ProvidersConfig.DEFAULT.mojang();
+        }
+
+        if (this.ely_by == null) {
+            SkinRestorer.LOGGER.warn("Ely.By provider config is null, using default");
+            this.ely_by = ProvidersConfig.DEFAULT.ely_by();
+        }
+
+        if (this.mineskin == null) {
+            SkinRestorer.LOGGER.warn("Mineskin provider config is null, using default");
+            this.mineskin = ProvidersConfig.DEFAULT.mineskin();
+        }
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/mineskin/Java11RequestHandler.java

@@ -0,0 +1,187 @@
+package net.lionarius.skinrestorer.mineskin;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import org.mineskin.MineSkinClientImpl;
+import org.mineskin.data.CodeAndMessage;
+import org.mineskin.exception.MineSkinRequestException;
+import org.mineskin.exception.MineskinException;
+import org.mineskin.request.RequestHandler;
+import org.mineskin.response.MineSkinResponse;
+import org.mineskin.response.ResponseConstructor;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.InetSocketAddress;
+import java.net.ProxySelector;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpRequest.BodyPublishers;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+
+// copy-pasted from https://github.com/InventivetalentDev/MineskinClient/blob/master/java11/src/main/java/org/mineskin/Java11RequestHandler.java
+// with some modifications to support proxy
+public class Java11RequestHandler extends RequestHandler {
+    
+    private final Gson gson;
+    private final HttpClient httpClient;
+    
+    public Java11RequestHandler(String userAgent, String apiKey, int timeout, Gson gson, InetSocketAddress proxy) {
+        super(userAgent, apiKey, timeout, gson);
+        this.gson = gson;
+        
+        HttpClient.Builder clientBuilder = HttpClient.newBuilder()
+                .connectTimeout(java.time.Duration.ofMillis(timeout));
+        
+        if (userAgent != null) {
+            clientBuilder.followRedirects(HttpClient.Redirect.NORMAL);
+        }
+        
+        if (proxy != null) {
+            clientBuilder.proxy(ProxySelector.of(proxy));
+        }
+        
+        this.httpClient = clientBuilder.build();
+    }
+    
+    private <T, R extends MineSkinResponse<T>> R wrapResponse(HttpResponse<String> response, Class<T> clazz, ResponseConstructor<T, R> constructor)
+            throws IOException {
+        String rawBody = response.body();
+        try {
+            JsonObject jsonBody = gson.fromJson(rawBody, JsonObject.class);
+            R wrapped = constructor.construct(
+                    response.statusCode(),
+                    lowercaseHeaders(response.headers().map()),
+                    jsonBody,
+                    gson, clazz
+            );
+            if (!wrapped.isSuccess()) {
+                throw new MineSkinRequestException(
+                        wrapped.getFirstError().map(CodeAndMessage::code).orElse("request_failed"),
+                        wrapped.getFirstError().map(CodeAndMessage::message).orElse("Request Failed"),
+                        wrapped
+                );
+            }
+            return wrapped;
+        } catch (JsonParseException e) {
+            MineSkinClientImpl.LOGGER.log(Level.WARNING, "Failed to parse response body: " + rawBody, e);
+            throw new MineskinException("Failed to parse response", e);
+        }
+    }
+    
+    private Map<String, String> lowercaseHeaders(Map<String, java.util.List<String>> headers) {
+        return headers.entrySet().stream()
+                .collect(Collectors.toMap(
+                        entry -> entry.getKey().toLowerCase(),
+                        entry -> String.join(", ", entry.getValue())
+                ));
+    }
+    
+    public <T, R extends MineSkinResponse<T>> R getJson(String url, Class<T> clazz, ResponseConstructor<T, R> constructor)
+            throws IOException {
+        MineSkinClientImpl.LOGGER.fine("GET " + url);
+        
+        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
+                .uri(URI.create(url))
+                .GET()
+                .header("User-Agent", this.userAgent);
+        HttpRequest request;
+        if (apiKey != null) {
+            request = requestBuilder
+                    .header("Authorization", "Bearer " + apiKey)
+                    .header("Accept", "application/json").build();
+        } else {
+            request = requestBuilder.build();
+        }
+        HttpResponse<String> response;
+        try {
+            response = this.httpClient.send(request, BodyHandlers.ofString());
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        return wrapResponse(response, clazz, constructor);
+    }
+    
+    public <T, R extends MineSkinResponse<T>> R postJson(String url, JsonObject data, Class<T> clazz, ResponseConstructor<T, R> constructor)
+            throws IOException {
+        MineSkinClientImpl.LOGGER.fine("POST " + url);
+        
+        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
+                .uri(URI.create(url))
+                .POST(BodyPublishers.ofString(gson.toJson(data)))
+                .header("Content-Type", "application/json")
+                .header("User-Agent", this.userAgent);
+        HttpRequest request;
+        if (apiKey != null) {
+            request = requestBuilder
+                    .header("Authorization", "Bearer " + apiKey)
+                    .header("Accept", "application/json").build();
+        } else {
+            request = requestBuilder.build();
+        }
+        
+        HttpResponse<String> response;
+        try {
+            response = this.httpClient.send(request, BodyHandlers.ofString());
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        return wrapResponse(response, clazz, constructor);
+    }
+    
+    public <T, R extends MineSkinResponse<T>> R postFormDataFile(String url, String key, String filename, InputStream in, Map<String, String> data, Class<T> clazz, ResponseConstructor<T, R> constructor)
+            throws IOException {
+        MineSkinClientImpl.LOGGER.fine("POST " + url);
+        
+        String boundary = "mineskin-" + System.currentTimeMillis();
+        StringBuilder bodyBuilder = new StringBuilder();
+        
+        // add form fields
+        for (Map.Entry<String, String> entry : data.entrySet()) {
+            bodyBuilder.append("--").append(boundary).append("\r\n")
+                    .append("Content-Disposition: form-data; name=\"").append(entry.getKey()).append("\"\r\n\r\n")
+                    .append(entry.getValue()).append("\r\n");
+        }
+        
+        // add file
+        byte[] fileContent = in.readAllBytes();
+        bodyBuilder.append("--").append(boundary).append("\r\n")
+                .append("Content-Disposition: form-data; name=\"").append(key)
+                .append("\"; filename=\"").append(filename).append("\"\r\n")
+                .append("Content-Type: image/png\r\n\r\n");
+        byte[] bodyStart = bodyBuilder.toString().getBytes();
+        byte[] boundaryEnd = ("\r\n--" + boundary + "--\r\n").getBytes();
+        byte[] bodyString = new byte[bodyStart.length + fileContent.length + boundaryEnd.length];
+        System.arraycopy(bodyStart, 0, bodyString, 0, bodyStart.length);
+        System.arraycopy(fileContent, 0, bodyString, bodyStart.length, fileContent.length);
+        System.arraycopy(boundaryEnd, 0, bodyString, bodyStart.length + fileContent.length, boundaryEnd.length);
+        
+        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
+                .uri(URI.create(url))
+                .POST(HttpRequest.BodyPublishers.ofByteArray(bodyString))
+                .header("Content-Type", "multipart/form-data; boundary=" + boundary)
+                .header("User-Agent", this.userAgent);
+        HttpRequest request;
+        if (apiKey != null) {
+            request = requestBuilder
+                    .header("Authorization", "Bearer " + apiKey)
+                    .header("Accept", "application/json").build();
+        } else {
+            request = requestBuilder.build();
+        }
+        
+        HttpResponse<String> response;
+        try {
+            response = this.httpClient.send(request, BodyHandlers.ofString());
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        return wrapResponse(response, clazz, constructor);
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/mixin/PlayerListMixin.java

@@ -27,13 +27,13 @@ public abstract class PlayerListMixin {
     
     @Inject(method = "remove", at = @At("TAIL"))
     private void remove(ServerPlayer player, CallbackInfo ci) {
-        SkinRestorer.getSkinStorage().removeSkin(player.getUUID());
+        SkinRestorer.Events.onPlayerDisconnect(player);
     }
     
     @Inject(method = "removeAll", at = @At("HEAD"))
     private void removeAll(CallbackInfo ci) {
-        for (ServerPlayer player : getPlayers()) {
+        for (var player : getPlayers()) {
-            SkinRestorer.getSkinStorage().removeSkin(player.getUUID());
+            SkinRestorer.Events.onPlayerDisconnect(player);
         }
     }
     

common/src/main/java/net/lionarius/skinrestorer/mixin/ServerLoginPacketListenerImplMixin.java

@@ -72,17 +72,17 @@ public abstract class ServerLoginPacketListenerImplMixin {
     
     @Unique
     private static void skinrestorer$fetchSkin(GameProfile profile, SkinProviderContext context) {
-        SkinRestorer.LOGGER.debug("fetching {}'s skin", profile.getName());
+        SkinRestorer.LOGGER.debug("Fetching {}'s skin", profile.getName());
         
         var result = SkinRestorer.getProvider(context.name()).map(
                 provider -> provider.fetchSkin(context.argument(), context.variant())
-        ).orElseGet(() -> Result.error(new IllegalArgumentException("skin provider is not registered: " + context.name())));
+        ).orElseGet(() -> Result.error(new IllegalArgumentException("Skin provider is not registered: " + context.name())));
         
         if (!result.isError()) {
             var value = SkinValue.fromProviderContextWithValue(context, result.getSuccessValue().orElse(null));
             SkinRestorer.getSkinStorage().setSkin(profile.getId(), value);
         } else {
-            SkinRestorer.LOGGER.warn("failed to fetch skin", result.getErrorValue());
+            SkinRestorer.LOGGER.warn("Failed to fetch skin: {}", result.getErrorValue().getMessage());
         }
     }
 }

common/src/main/java/net/lionarius/skinrestorer/platform/Services.java

@@ -1,6 +1,7 @@
 package net.lionarius.skinrestorer.platform;
 
 import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.platform.services.CompatibilityHelper;
 import net.lionarius.skinrestorer.platform.services.PlatformHelper;
 
 import java.util.ServiceLoader;
@@ -8,8 +9,9 @@ import java.util.ServiceLoader;
 public final class Services {
     
     private Services() {}
-
+    
     public final static PlatformHelper PLATFORM = load(PlatformHelper.class);
+    public final static CompatibilityHelper COMPATIBILITY = load(CompatibilityHelper.class);
     
     private static <T> T load(Class<T> clazz) {
         final T loadedService = ServiceLoader.load(clazz)

common/src/main/java/net/lionarius/skinrestorer/platform/services/CompatibilityHelper.java

@@ -0,0 +1,8 @@
+package net.lionarius.skinrestorer.platform.services;
+
+import net.minecraft.server.level.ServerPlayer;
+
+public interface CompatibilityHelper {
+    
+    void skinShuffle_sendHandshake(ServerPlayer player);
+}

common/src/main/java/net/lionarius/skinrestorer/skin/provider/ElyBySkinProvider.java

@@ -36,7 +36,11 @@ public final class ElyBySkinProvider implements SkinProvider {
         }
     }
     
-    public static void createCache() {
+    public static void reload() {
+        createCache();
+    }
+    
+    private static void createCache() {
         var config = SkinRestorer.getConfig().providersConfig().ely_by();
         var time = config.cache().enabled() ? config.cache().duration() : 0;
         

common/src/main/java/net/lionarius/skinrestorer/skin/provider/MineskinSkinProvider.java

@@ -4,21 +4,26 @@ import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.CacheLoader;
 import com.google.common.cache.LoadingCache;
 import com.google.common.util.concurrent.UncheckedExecutionException;
-import com.google.gson.JsonObject;
 import com.mojang.authlib.properties.Property;
 import it.unimi.dsi.fastutil.Pair;
 import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.mineskin.Java11RequestHandler;
 import net.lionarius.skinrestorer.skin.SkinVariant;
 import net.lionarius.skinrestorer.util.JsonUtils;
 import net.lionarius.skinrestorer.util.PlayerUtils;
 import net.lionarius.skinrestorer.util.Result;
 import net.lionarius.skinrestorer.util.WebUtils;
 import org.jetbrains.annotations.NotNull;
+import org.mineskin.MineSkinClient;
+import org.mineskin.data.Variant;
+import org.mineskin.data.Visibility;
+import org.mineskin.request.GenerateRequest;
+import org.mineskin.response.QueueResponse;
 
-import java.io.IOException;
+import java.net.InetSocketAddress;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.net.http.HttpRequest;
+import java.time.Duration;
 import java.util.Optional;
 import java.util.concurrent.TimeUnit;
 
@@ -27,6 +32,7 @@ public final class MineskinSkinProvider implements SkinProvider {
     public static final String PROVIDER_NAME = "web";
     
     private static final URI API_URI;
+    private static MineSkinClient MINESKIN_CLIENT;
     
     private static LoadingCache<Pair<URI, SkinVariant>, Optional<Property>> SKIN_CACHE;
     
@@ -38,7 +44,29 @@ public final class MineskinSkinProvider implements SkinProvider {
         }
     }
     
-    public static void createCache() {
+    public static void reload() {
+        var config = SkinRestorer.getConfig();
+        var configApiKey = config.providersConfig().mineskin().apiKey();
+        
+        MINESKIN_CLIENT = MineSkinClient
+                .builder()
+                .userAgent(WebUtils.USER_AGENT)
+                .gson(JsonUtils.GSON)
+                .timeout((int) Duration.ofSeconds(config.requestTimeout()).toMillis())
+                .requestHandler((userAgent, apiKey, timeout, gson) -> new Java11RequestHandler(
+                        userAgent,
+                        apiKey,
+                        timeout,
+                        gson,
+                        SkinRestorer.getConfig().proxy().map(proxy -> new InetSocketAddress(proxy.host(), proxy.port())).orElse(null)
+                ))
+                .apiKey(configApiKey.isEmpty() ? null : configApiKey)
+                .build();
+        
+        createCache();
+    }
+    
+    private static void createCache() {
         var config = SkinRestorer.getConfig().providersConfig().mineskin();
         var time = config.cache().enabled() ? config.cache().duration() : 0;
         
@@ -76,29 +104,26 @@ public final class MineskinSkinProvider implements SkinProvider {
     }
     
     private static Optional<Property> loadSkin(URI uri, SkinVariant variant) throws Exception {
-        var result = MineskinSkinProvider.uploadToMineskin(uri, variant);
+        var mineskinVariant = switch (variant) {
-        var texture = result.getAsJsonObject("data").getAsJsonObject("texture");
+            case CLASSIC -> Variant.CLASSIC;
-        var textures = new Property(PlayerUtils.TEXTURES_KEY, texture.get("value").getAsString(), texture.get("signature").getAsString());
+            case SLIM -> Variant.SLIM;
+        };
         
-        return Optional.of(textures);
+        var request = GenerateRequest.url(uri)
-    }
+                .variant(mineskinVariant)
-    
+                .name("skinrestorer-skin")
-    private static JsonObject uploadToMineskin(URI url, SkinVariant variant) throws IOException {
+                .visibility(Visibility.UNLISTED);
-        var body = ("{\"variant\":\"%s\",\"name\":\"%s\",\"visibility\":%d,\"url\":\"%s\"}")
-                .formatted(variant.toString(), "none", 0, url);
         
-        var request = HttpRequest.newBuilder()
+        var skin = MINESKIN_CLIENT.queue().submit(request)
-                .uri(MineskinSkinProvider.API_URI.resolve("/generate/url"))
+                .thenApply(QueueResponse::getJob)
-                .POST(HttpRequest.BodyPublishers.ofString(body))
+                .thenCompose(jobInfo -> jobInfo.waitForCompletion(MINESKIN_CLIENT))
-                .header("Content-Type", "application/json")
+                .thenCompose(jobReference -> jobReference.getOrLoadSkin(MINESKIN_CLIENT))
-                .build();
+                .join();
         
-        var response = WebUtils.executeRequest(request);
+        return Optional.of(new Property(
-        WebUtils.throwOnClientErrors(response);
+                PlayerUtils.TEXTURES_KEY,
-        
+                skin.texture().data().value(),
-        if (response.statusCode() != 200)
+                skin.texture().data().signature()
-            throw new IllegalArgumentException("could not get mineskin skin");
+        ));
-        
-        return JsonUtils.parseJson(response.body());
     }
 }

common/src/main/java/net/lionarius/skinrestorer/skin/provider/MojangSkinProvider.java

@@ -52,11 +52,13 @@ public final class MojangSkinProvider implements SkinProvider {
                 }
             }
         }, SkinRestorer.getConfigDir().resolve(PROFILE_CACHE_FILENAME).toFile());
-        
-        
     }
     
-    public static void createCache() {
+    public static void reload() {
+        createCache();
+    }
+    
+    private static void createCache() {
         var config = SkinRestorer.getConfig().providersConfig().mojang();
         var time = config.cache().enabled() ? config.cache().duration() : 0;
         

common/src/main/java/net/lionarius/skinrestorer/skin/provider/SkinProvider.java

@@ -1,18 +1,27 @@
 package net.lionarius.skinrestorer.skin.provider;
 
+import com.google.common.collect.ImmutableSet;
 import com.mojang.authlib.properties.Property;
 import net.lionarius.skinrestorer.skin.SkinVariant;
 import net.lionarius.skinrestorer.util.Result;
 
 import java.util.Optional;
+import java.util.Set;
 
 public interface SkinProvider {
     EmptySkinProvider EMPTY = new EmptySkinProvider();
     MojangSkinProvider MOJANG = new MojangSkinProvider();
     ElyBySkinProvider ELY_BY = new ElyBySkinProvider();
     MineskinSkinProvider MINESKIN = new MineskinSkinProvider();
+    SkinShuffleSkinProvider SKIN_SHUFFLE = new SkinShuffleSkinProvider();
     
-    String[] BUILTIN_PROVIDER_NAMES = new String[]{EmptySkinProvider.PROVIDER_NAME, MojangSkinProvider.PROVIDER_NAME, ElyBySkinProvider.PROVIDER_NAME, MineskinSkinProvider.PROVIDER_NAME};
+    Set<String> BUILTIN_PROVIDER_NAMES = ImmutableSet.of(
+            EmptySkinProvider.PROVIDER_NAME,
+            MojangSkinProvider.PROVIDER_NAME,
+            ElyBySkinProvider.PROVIDER_NAME,
+            MineskinSkinProvider.PROVIDER_NAME,
+            SkinShuffleSkinProvider.PROVIDER_NAME
+    );
     
     String getArgumentName();
     

common/src/main/java/net/lionarius/skinrestorer/skin/provider/SkinShuffleSkinProvider.java

@@ -0,0 +1,27 @@
+package net.lionarius.skinrestorer.skin.provider;
+
+import com.mojang.authlib.properties.Property;
+import net.lionarius.skinrestorer.skin.SkinVariant;
+import net.lionarius.skinrestorer.util.Result;
+
+import java.util.Optional;
+
+public final class SkinShuffleSkinProvider implements SkinProvider {
+    
+    public static final String PROVIDER_NAME = "skinshuffle";
+    
+    @Override
+    public String getArgumentName() {
+        return "unsupported";
+    }
+    
+    @Override
+    public boolean hasVariantSupport() {
+        return false;
+    }
+    
+    @Override
+    public Result<Optional<Property>, Exception> fetchSkin(String argument, SkinVariant variant) {
+        return Result.error(new UnsupportedOperationException("SkinShuffle Provider does not support fetching skins"));
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/util/FileUtils.java

@@ -42,7 +42,7 @@ public final class FileUtils {
                 }
             }
         } catch (Exception e) {
-            SkinRestorer.LOGGER.error("could not migrate skin directory", e);
+            SkinRestorer.LOGGER.error("Could not migrate skin directory", e);
         }
     }
     
@@ -55,7 +55,7 @@ public final class FileUtils {
                 return StringUtils.readString(reader);
             }
         } catch (IOException e) {
-            SkinRestorer.LOGGER.error("failed to read resource", e);
+            SkinRestorer.LOGGER.error("Failed to read resource", e);
             return null;
         }
     }
@@ -67,7 +67,7 @@ public final class FileUtils {
             
             return Files.readString(file);
         } catch (Exception e) {
-            SkinRestorer.LOGGER.error("failed to read file", e);
+            SkinRestorer.LOGGER.error("Failed to read file", e);
             return null;
         }
     }
@@ -83,7 +83,7 @@ public final class FileUtils {
             
             Files.writeString(file, content);
         } catch (IOException e) {
-            SkinRestorer.LOGGER.error("failed to write file", e);
+            SkinRestorer.LOGGER.error("Failed to write file", e);
         }
     }
     
@@ -92,7 +92,7 @@ public final class FileUtils {
             if (Files.exists(file))
                 Files.delete(file);
         } catch (IOException e) {
-            SkinRestorer.LOGGER.error("failed to delete file", e);
+            SkinRestorer.LOGGER.error("Failed to delete file", e);
         }
     }
 }

common/src/main/java/net/lionarius/skinrestorer/util/JsonUtils.java

@@ -9,6 +9,7 @@ import com.mojang.authlib.properties.Property;
 import com.mojang.authlib.properties.PropertyMap;
 import com.mojang.util.UUIDTypeAdapter;
 import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.util.gson.PostProcessingEnabler;
 
 import java.lang.reflect.Type;
 import java.nio.charset.StandardCharsets;
@@ -17,7 +18,8 @@ import java.util.UUID;
 
 public final class JsonUtils {
     
-    private static final Gson GSON = new GsonBuilder()
+    public static final Gson GSON = new GsonBuilder()
+            .registerTypeAdapterFactory(new PostProcessingEnabler())
             .registerTypeAdapter(UUID.class, new UUIDTypeAdapter())
             .registerTypeAdapter(PropertyMap.class, new PropertyMap.Serializer())
             .registerTypeAdapter(GameProfile.class, new GameProfile.Serializer())
@@ -54,7 +56,7 @@ public final class JsonUtils {
             
             return json;
         } catch (Exception e) {
-            SkinRestorer.LOGGER.error(e.toString());
+            SkinRestorer.LOGGER.error("Could not parse skin property", e);
             return null;
         }
     }

common/src/main/java/net/lionarius/skinrestorer/util/WebUtils.java

@@ -36,7 +36,7 @@ public final class WebUtils {
         try {
             builder.connectTimeout(Duration.of(SkinRestorer.getConfig().requestTimeout(), ChronoUnit.SECONDS));
         } catch (IllegalArgumentException e) {
-            SkinRestorer.LOGGER.error("failed to set request timeout", e);
+            SkinRestorer.LOGGER.error("Failed to set request timeout", e);
             builder.connectTimeout(Duration.of(10, ChronoUnit.SECONDS));
         }
         

common/src/main/java/net/lionarius/skinrestorer/util/gson/GsonPostProcessable.java

@@ -0,0 +1,5 @@
+package net.lionarius.skinrestorer.util.gson;
+
+public interface GsonPostProcessable {
+    void gsonPostProcess();
+}

common/src/main/java/net/lionarius/skinrestorer/util/gson/PostProcessingEnabler.java

@@ -0,0 +1,34 @@
+package net.lionarius.skinrestorer.util.gson;
+
+import com.google.gson.Gson;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+
+import java.io.IOException;
+
+public class PostProcessingEnabler implements TypeAdapterFactory {
+    @Override
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
+        var adapter = gson.getDelegateAdapter(this, type);
+        
+        return new TypeAdapter<>() {
+            @Override
+            public void write(JsonWriter out, T value) throws IOException {
+                adapter.write(out, value);
+            }
+            
+            @Override
+            public T read(JsonReader in) throws IOException {
+                var value = adapter.read(in);
+                
+                if (value instanceof GsonPostProcessable postProcessable)
+                    postProcessable.gsonPostProcess();
+                
+                return value;
+            }
+        };
+    }
+}

common/src/main/resources/skinrestorer.mixins.json

@@ -5,9 +5,9 @@
     "compatibilityLevel": "JAVA_8",
     "refmap": "${mod_id}.refmap.json",
     "mixins": [
+        "ChunkMapAccessor",
         "PlayerListMixin",
         "ServerLoginPacketListenerImplMixin",
-        "ChunkMapAccessor",
         "TrackedEntityAccessorInvoker"
     ],
     "injectors": {

fabric/build.gradle

@@ -1,10 +1,11 @@
 plugins {
     id 'multiloader-loader'
-    
+
     id 'fabric-loom'
 
     id 'multiloader-publish'
 }
+
 dependencies {
     minecraft "com.mojang:minecraft:${minecraft_version}"
     mappings loom.layered {
@@ -12,6 +13,10 @@ dependencies {
         parchment("org.parchmentmc.data:parchment-${parchment_minecraft}:${parchment_version}@zip")
     }
     modImplementation "net.fabricmc:fabric-loader:${fabric_loader_version}"
+
+    modCompileOnly "net.fabricmc.fabric-api:fabric-api:${fabric_api_version}"
+
+    include implementation("org.mineskin:java-client:${mineskin_client_version}")
 }
 
 loom {
@@ -19,11 +24,11 @@ loom {
     if (aw.exists()) {
         accessWidenerPath.set(aw)
     }
-    
+
     mixin {
         defaultRefmapName.set("${mod_id}.refmap.json")
     }
-    
+
     runs {
         client {
             client()

fabric/src/main/java/net/lionarius/skinrestorer/fabric/SkinRestorerFabric.java

@@ -2,10 +2,18 @@ package net.lionarius.skinrestorer.fabric;
 
 import net.fabricmc.api.ModInitializer;
 import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
+import net.lionarius.skinrestorer.platform.Services;
 
 public final class SkinRestorerFabric implements ModInitializer {
+    
+    public static final boolean FABRIC_API_LOADED = Services.PLATFORM.isModLoaded("fabric-api");
+    
     @Override
     public void onInitialize() {
         SkinRestorer.onInitialize();
+        
+        if (SkinShuffleCompatibility.shouldApply())
+            net.lionarius.skinrestorer.fabric.compat.skinshuffle.SkinShuffleCompatibility.initialize();
     }
 }

fabric/src/main/java/net/lionarius/skinrestorer/fabric/compat/skinshuffle/SkinShuffleCompatibility.java

@@ -0,0 +1,46 @@
+package net.lionarius.skinrestorer.fabric.compat.skinshuffle;
+
+import net.fabricmc.fabric.api.networking.v1.PacketSender;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleSkinRefreshPayload;
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleSkinRefreshV1Payload;
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleSkinRefreshV2Payload;
+import net.lionarius.skinrestorer.fabric.SkinRestorerFabric;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.network.ServerGamePacketListenerImpl;
+
+public final class SkinShuffleCompatibility {
+    
+    private SkinShuffleCompatibility() {}
+    
+    public static void initialize() {
+        if (!SkinRestorerFabric.FABRIC_API_LOADED) {
+            SkinRestorer.LOGGER.warn("fabric-api is not loaded, SkinShuffle compatibility will not be available");
+            return;
+        }
+        
+        ServerPlayConnectionEvents.JOIN.register((handler, sender, server) -> net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility.onPlayerJoin(handler.getPlayer()));
+        
+        ServerPlayNetworking.registerGlobalReceiver(SkinShuffleSkinRefreshV1Payload.PACKET_ID, SkinShuffleCompatibility::handleSkinRefreshV1Packet);
+        
+        ServerPlayNetworking.registerGlobalReceiver(SkinShuffleSkinRefreshV2Payload.PACKET_ID, SkinShuffleCompatibility::handleSkinRefreshV2Packet);
+    }
+    
+    private static void handleSkinRefreshV1Packet(MinecraftServer server, ServerPlayer player, ServerGamePacketListenerImpl listener, FriendlyByteBuf buf, PacketSender sender) {
+        var payload = SkinShuffleSkinRefreshV1Payload.decode(buf);
+        SkinShuffleCompatibility.handleSkinRefreshPacket(payload, server, player);
+    }
+    
+    private static void handleSkinRefreshV2Packet(MinecraftServer server, ServerPlayer player, ServerGamePacketListenerImpl listener, FriendlyByteBuf buf, PacketSender sender) {
+        var payload = SkinShuffleSkinRefreshV2Payload.decode(buf);
+        SkinShuffleCompatibility.handleSkinRefreshPacket(payload, server, player);
+    }
+    
+    private static void handleSkinRefreshPacket(SkinShuffleSkinRefreshPayload payload, MinecraftServer server, ServerPlayer player) {
+        net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility.handleSkinRefresh(server, player, payload);
+    }
+}

fabric/src/main/java/net/lionarius/skinrestorer/fabric/mixin/CommandsMixin.java

@@ -1,7 +1,7 @@
 package net.lionarius.skinrestorer.fabric.mixin;
 
 import com.mojang.brigadier.CommandDispatcher;
-import net.lionarius.skinrestorer.command.SkinCommand;
+import net.lionarius.skinrestorer.SkinRestorer;
 import net.minecraft.commands.CommandBuildContext;
 import net.minecraft.commands.CommandSourceStack;
 import net.minecraft.commands.Commands;
@@ -21,6 +21,6 @@ public abstract class CommandsMixin {
     @Inject(method = "<init>", at = @At(value = "INVOKE",
                                         target = "Lnet/minecraft/server/commands/AdvancementCommands;register(Lcom/mojang/brigadier/CommandDispatcher;)V"))
     private void init(Commands.CommandSelection environment, CommandBuildContext commandRegistryAccess, CallbackInfo ci) {
-        SkinCommand.register(dispatcher);
+        SkinRestorer.Events.onCommandRegister(dispatcher);
     }
 }

fabric/src/main/java/net/lionarius/skinrestorer/fabric/mixin/MinecraftServerMixin.java

@@ -13,6 +13,6 @@ public abstract class MinecraftServerMixin {
     @Inject(method = "runServer",
             at = @At(value = "INVOKE", target = "Lnet/minecraft/Util;getMillis()J", ordinal = 0))
     private void onServerStarted(CallbackInfo ci) {
-        SkinRestorer.onServerStarted((MinecraftServer) (Object) this);
+        SkinRestorer.Events.onServerStarted((MinecraftServer) (Object) this);
     }
 }

fabric/src/main/java/net/lionarius/skinrestorer/fabric/platform/FabricCompatibilityHelper.java

@@ -0,0 +1,14 @@
+package net.lionarius.skinrestorer.fabric.platform;
+
+import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleHandshakePayload;
+import net.lionarius.skinrestorer.platform.services.CompatibilityHelper;
+import net.minecraft.server.level.ServerPlayer;
+
+public final class FabricCompatibilityHelper implements CompatibilityHelper {
+    @Override
+    public void skinShuffle_sendHandshake(ServerPlayer player) {
+        ServerPlayNetworking.send(player, SkinShuffleHandshakePayload.PACKET_ID, PacketByteBufs.empty());
+    }
+}

fabric/src/main/resources/META-INF/services/net.lionarius.skinrestorer.platform.services.CompatibilityHelper

@@ -0,0 +1 @@
+net.lionarius.skinrestorer.fabric.platform.FabricCompatibilityHelper

fabric/src/main/resources/fabric.mod.json

@@ -28,5 +28,8 @@
         "fabricloader": ">=${fabric_loader_version}",
         "minecraft": ">=${minecraft_version}",
         "java": ">=${java_version}"
+    },
+    "suggests": {
+        "fabric-api": "*"
     }
 }

forge/build.gradle

@@ -2,7 +2,7 @@ plugins {
     id 'multiloader-loader'
     id 'idea'
     id 'eclipse'
-    
+
     id 'net.minecraftforge.gradle'
     id 'org.parchmentmc.librarian.forgegradle'
     id 'org.spongepowered.mixin'
@@ -15,6 +15,16 @@ mixin {
     config "${mod_id}.mixins.json"
 }
 
+jarJar.enable()
+
+tasks.named('jar') {
+    archiveClassifier = 'thin'
+}
+
+tasks.named('jarJar') {
+    archiveClassifier = ''
+}
+
 minecraft {
     mappings channel: 'parchment', version: "${parchment_version}-${parchment_minecraft}"
 
@@ -58,6 +68,10 @@ dependencies {
 
     annotationProcessor('org.spongepowered:mixin:0.8.5-SNAPSHOT:processor')
     implementation('net.sf.jopt-simple:jopt-simple:5.0.4') { version { strictly '5.0.4' } }
+
+    minecraftLibrary(jarJar(group: 'org.mineskin', name: 'java-client', version: mineskin_client_version)) {
+        jarJar.ranged(it, "[${mineskin_client_version},)")
+    }
 }
 
 // for some reason mixin plugin does not add 'MixinConfigs' to MANIFEST.MF so we do it manually

forge/src/main/java/net/lionarius/skinrestorer/forge/SkinRestorerForge.java

@@ -1,8 +1,7 @@
 package net.lionarius.skinrestorer.forge;
 
 import net.lionarius.skinrestorer.SkinRestorer;
-import net.lionarius.skinrestorer.command.SkinCommand;
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
-import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.event.RegisterCommandsEvent;
 import net.minecraftforge.event.server.ServerStartedEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
@@ -13,18 +12,19 @@ import net.minecraftforge.fml.common.Mod;
 public final class SkinRestorerForge {
     
     public SkinRestorerForge() {
-        MinecraftForge.EVENT_BUS.register(SkinRestorerForge.class);
-        
         SkinRestorer.onInitialize();
+        
+        if (SkinShuffleCompatibility.shouldApply())
+            net.lionarius.skinrestorer.forge.compat.skinshuffle.SkinShuffleCompatibility.initialize();
     }
     
     @SubscribeEvent
     public static void onCommandRegister(RegisterCommandsEvent event) {
-        SkinCommand.register(event.getDispatcher());
+        SkinRestorer.Events.onCommandRegister(event.getDispatcher());
     }
     
     @SubscribeEvent
     public static void onServerStarted(ServerStartedEvent event) {
-        SkinRestorer.onServerStarted(event.getServer());
+        SkinRestorer.Events.onServerStarted(event.getServer());
     }
 }

forge/src/main/java/net/lionarius/skinrestorer/forge/compat/skinshuffle/SkinShuffleCompatibility.java

@@ -0,0 +1,14 @@
+package net.lionarius.skinrestorer.forge.compat.skinshuffle;
+
+import net.minecraftforge.common.MinecraftForge;
+
+public final class SkinShuffleCompatibility {
+    
+    private SkinShuffleCompatibility() {}
+    
+    public static void initialize() {
+        MinecraftForge.EVENT_BUS.register(SkinShuffleGameEventHandler.class);
+        
+        SkinShufflePacketHandler.initialize();
+    }
+}

forge/src/main/java/net/lionarius/skinrestorer/forge/compat/skinshuffle/SkinShuffleGameEventHandler.java

@@ -0,0 +1,16 @@
+package net.lionarius.skinrestorer.forge.compat.skinshuffle;
+
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraftforge.event.entity.player.PlayerEvent;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+
+public final class SkinShuffleGameEventHandler {
+    
+    private SkinShuffleGameEventHandler() {}
+    
+    @SubscribeEvent
+    public static void onPlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent event) {
+        SkinShuffleCompatibility.onPlayerJoin((ServerPlayer) event.getEntity());
+    }
+}

forge/src/main/java/net/lionarius/skinrestorer/forge/compat/skinshuffle/SkinShufflePacketHandler.java

@@ -0,0 +1,59 @@
+package net.lionarius.skinrestorer.forge.compat.skinshuffle;
+
+import io.netty.buffer.Unpooled;
+import net.lionarius.skinrestorer.compat.skinshuffle.*;
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
+import net.minecraft.network.Connection;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.event.network.CustomPayloadEvent;
+import net.minecraftforge.network.ChannelBuilder;
+import net.minecraftforge.network.EventNetworkChannel;
+
+public class SkinShufflePacketHandler {
+    private SkinShufflePacketHandler() {
+    }
+
+    private static final EventNetworkChannel HANDSHAKE_INSTANCE = ChannelBuilder
+            .named(SkinShuffleHandshakePayload.PACKET_ID)
+            .optional()
+            .eventNetworkChannel();
+    
+    private static final EventNetworkChannel SKIN_REFRESH_V1_INSTANCE = ChannelBuilder
+            .named(SkinShuffleSkinRefreshV1Payload.PACKET_ID)
+            .optional()
+            .eventNetworkChannel()
+            .addListener(SkinShufflePacketHandler::skinRefreshV1Listener);
+    
+    private static final EventNetworkChannel SKIN_REFRESH_V2_INSTANCE = ChannelBuilder
+            .named(SkinShuffleSkinRefreshV2Payload.PACKET_ID)
+            .optional()
+            .eventNetworkChannel()
+            .addListener(SkinShufflePacketHandler::skinRefreshV2Listener);
+
+    protected static void initialize() {
+        // NO-OP
+    }
+
+    public static void sendHandshake(Connection connection) {
+        HANDSHAKE_INSTANCE.send(new FriendlyByteBuf(Unpooled.buffer(0, 0)), connection);
+    }
+    
+    private static void skinRefreshV1Listener(CustomPayloadEvent event) {
+        var payload = SkinShuffleSkinRefreshV1Payload.decode(event.getPayload());
+        handleSkinRefreshPacket(payload, event.getSource());
+    }
+
+    private static void skinRefreshV2Listener(CustomPayloadEvent event) {
+        var payload = SkinShuffleSkinRefreshV2Payload.decode(event.getPayload());
+        handleSkinRefreshPacket(payload, event.getSource());
+    }
+
+    private static void handleSkinRefreshPacket(SkinShuffleSkinRefreshPayload payload, CustomPayloadEvent.Context context) {
+        var sender = context.getSender();
+        
+        if (!context.isServerSide() || sender == null)
+            return;
+        
+        SkinShuffleCompatibility.handleSkinRefresh(sender.getServer(), sender, payload);
+    }
+}

forge/src/main/java/net/lionarius/skinrestorer/forge/platform/ForgeCompatibilityHelper.java

@@ -0,0 +1,13 @@
+package net.lionarius.skinrestorer.forge.platform;
+
+import net.lionarius.skinrestorer.forge.compat.skinshuffle.SkinShufflePacketHandler;
+import net.lionarius.skinrestorer.platform.services.CompatibilityHelper;
+import net.minecraft.server.level.ServerPlayer;
+
+public final class ForgeCompatibilityHelper implements CompatibilityHelper {
+    
+    @Override
+    public void skinShuffle_sendHandshake(ServerPlayer player) {
+        SkinShufflePacketHandler.sendHandshake(player.connection.getConnection());
+    }
+}

forge/src/main/resources/META-INF/services/net.lionarius.skinrestorer.platform.services.CompatibilityHelper

@@ -0,0 +1 @@
+net.lionarius.skinrestorer.forge.platform.ForgeCompatibilityHelper

gradle.properties

@@ -1,5 +1,5 @@
 # Project
-group=net.lionarius.skinrestorer
+group=net.lionarius
 java_version=17
 
 # Common
@@ -8,7 +8,7 @@ minecraft_version_list=1.20.2
 minecraft_version_range=1.20.2
 mod_id=skinrestorer
 mod_name=SkinRestorer
-mod_version=2.1.0
+mod_version=2.2.0
 mod_author=Lionarius
 mod_homepage=https://modrinth.com/mod/skinrestorer
 mod_sources=https://github.com/Suiranoil/SkinRestorer
@@ -17,12 +17,16 @@ license=MIT
 credits=
 description=A server-side mod for managing skins.
 
+mineskin_client_version=3.0.1-SNAPSHOT
+
 # ParchmentMC mappings, see https://parchmentmc.org/docs/getting-started#choose-a-version for new versions
 parchment_minecraft=1.20.2
 parchment_version=2023.12.10
 
 # Fabric, see https://fabricmc.net/develop/ for new versions
 fabric_loader_version=0.15.0
+fabric_api_version=0.91.1+1.20.3
+fabric_optional_dependencies=fabric-api
 
 # Forge, see https://files.minecraftforge.net/net/minecraftforge/forge/ for new versions
 forge_version=48.0.0

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -84,7 +86,8 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum

gradlew.bat

@@ -13,6 +13,8 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################

neoforge/build.gradle

@@ -14,6 +14,26 @@ if (at.exists()) {
     minecraft.accessTransformers.file(at)
 }
 
+jarJar.enable()
+
+tasks.named('jar') {
+    archiveClassifier = 'thin'
+}
+
+tasks.named('jarJar') {
+    archiveClassifier = ''
+}
+
+jar.finalizedBy('jarJar')
+
+dependencies {
+    implementation "net.neoforged:neoforge:${neoforge_version}"
+
+    implementation(jarJar(group: 'org.mineskin', name: 'java-client', version: mineskin_client_version)) {
+        jarJar.ranged(it, "[${mineskin_client_version},)")
+    }
+}
+
 subsystems {
     parchment {
         minecraftVersion = parchment_minecraft
@@ -36,7 +56,3 @@ runs {
         workingDirectory = file('../run/server')
     }
 }
-
-dependencies {
-    implementation "net.neoforged:neoforge:${neoforge_version}"
-}

neoforge/src/main/java/net/lionarius/skinrestorer/neoforge/SkinRestorerNeoForge.java

@@ -1,10 +1,9 @@
 package net.lionarius.skinrestorer.neoforge;
 
 import net.lionarius.skinrestorer.SkinRestorer;
-import net.lionarius.skinrestorer.command.SkinCommand;
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
 import net.neoforged.bus.api.SubscribeEvent;
 import net.neoforged.fml.common.Mod;
-import net.neoforged.neoforge.common.NeoForge;
 import net.neoforged.neoforge.event.RegisterCommandsEvent;
 import net.neoforged.neoforge.event.server.ServerStartedEvent;
 
@@ -13,18 +12,19 @@ import net.neoforged.neoforge.event.server.ServerStartedEvent;
 public final class SkinRestorerNeoForge {
     
     public SkinRestorerNeoForge() {
-        NeoForge.EVENT_BUS.register(SkinRestorerNeoForge.class);
-        
         SkinRestorer.onInitialize();
+        
+        if (SkinShuffleCompatibility.shouldApply())
+            net.lionarius.skinrestorer.neoforge.compat.skinshuffle.SkinShuffleCompatibility.initialize();
     }
     
     @SubscribeEvent
     public static void onCommandRegister(RegisterCommandsEvent event) {
-        SkinCommand.register(event.getDispatcher());
+        SkinRestorer.Events.onCommandRegister(event.getDispatcher());
     }
     
     @SubscribeEvent
     public static void onServerStarted(ServerStartedEvent event) {
-        SkinRestorer.onServerStarted(event.getServer());
+        SkinRestorer.Events.onServerStarted(event.getServer());
     }
 }

neoforge/src/main/java/net/lionarius/skinrestorer/neoforge/compat/skinshuffle/SkinShuffleCompatibility.java

@@ -0,0 +1,14 @@
+package net.lionarius.skinrestorer.neoforge.compat.skinshuffle;
+
+import net.neoforged.neoforge.common.NeoForge;
+
+public final class SkinShuffleCompatibility {
+    
+    private SkinShuffleCompatibility() {}
+    
+    public static void initialize() {
+        NeoForge.EVENT_BUS.register(SkinShuffleGameEventHandler.class);
+        
+        SkinShufflePacketHandler.initialize();
+    }
+}

neoforge/src/main/java/net/lionarius/skinrestorer/neoforge/compat/skinshuffle/SkinShuffleGameEventHandler.java

@@ -0,0 +1,16 @@
+package net.lionarius.skinrestorer.neoforge.compat.skinshuffle;
+
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
+import net.minecraft.server.level.ServerPlayer;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.neoforge.event.entity.player.PlayerEvent;
+
+public final class SkinShuffleGameEventHandler {
+    
+    private SkinShuffleGameEventHandler() {}
+    
+    @SubscribeEvent
+    public static void onPlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent event) {
+        SkinShuffleCompatibility.onPlayerJoin((ServerPlayer) event.getEntity());
+    }
+}

neoforge/src/main/java/net/lionarius/skinrestorer/neoforge/compat/skinshuffle/SkinShufflePacketHandler.java

@@ -0,0 +1,55 @@
+package net.lionarius.skinrestorer.neoforge.compat.skinshuffle;
+
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
+import net.lionarius.skinrestorer.compat.skinshuffle.*;
+import net.neoforged.neoforge.network.NetworkConstants;
+import net.neoforged.neoforge.network.NetworkEvent;
+import net.neoforged.neoforge.network.NetworkRegistry;
+import net.neoforged.neoforge.network.event.EventNetworkChannel;
+
+public final class SkinShufflePacketHandler {
+    private SkinShufflePacketHandler() {
+    }
+    
+    // there is no need for handshake channel but register it to not allow other mods to use it
+    private static final EventNetworkChannel HANDSHAKE_INSTANCE = NetworkRegistry.ChannelBuilder
+            .named(SkinShuffleHandshakePayload.PACKET_ID)
+            .serverAcceptedVersions(NetworkRegistry.acceptMissingOr("1"))
+            .clientAcceptedVersions(NetworkRegistry.acceptMissingOr("1"))
+            .networkProtocolVersion(() -> NetworkConstants.NETVERSION)
+            .eventNetworkChannel();
+    
+    private static final EventNetworkChannel SKIN_REFRESH_V1_INSTANCE = NetworkRegistry.ChannelBuilder
+            .named(SkinShuffleSkinRefreshV1Payload.PACKET_ID)
+            .serverAcceptedVersions(NetworkRegistry.acceptMissingOr("1"))
+            .clientAcceptedVersions(NetworkRegistry.acceptMissingOr("1"))
+            .networkProtocolVersion(() -> NetworkConstants.NETVERSION)
+            .eventNetworkChannel();
+    
+    private static final EventNetworkChannel SKIN_REFRESH_V2_INSTANCE = NetworkRegistry.ChannelBuilder
+            .named(SkinShuffleSkinRefreshV2Payload.PACKET_ID)
+            .serverAcceptedVersions(NetworkRegistry.acceptMissingOr("1"))
+            .clientAcceptedVersions(NetworkRegistry.acceptMissingOr("1"))
+            .networkProtocolVersion(() -> NetworkConstants.NETVERSION)
+            .eventNetworkChannel();
+    
+    static void initialize() {
+        SKIN_REFRESH_V1_INSTANCE.addListener(SkinShufflePacketHandler::skinRefreshV1Listener);
+        SKIN_REFRESH_V2_INSTANCE.addListener(SkinShufflePacketHandler::skinRefreshV2Listener);
+    }
+    
+    private static void skinRefreshV1Listener(NetworkEvent.ServerCustomPayloadEvent event) {
+        var payload = SkinShuffleSkinRefreshV1Payload.decode(event.getPayload());
+        handleSkinRefreshPacket(payload, event.getSource());
+    }
+    
+    private static void skinRefreshV2Listener(NetworkEvent.ServerCustomPayloadEvent event) {
+        var payload = SkinShuffleSkinRefreshV2Payload.decode(event.getPayload());
+        handleSkinRefreshPacket(payload, event.getSource());
+    }
+    
+    private static void handleSkinRefreshPacket(SkinShuffleSkinRefreshPayload payload, NetworkEvent.Context context) {
+        var player = context.getSender();
+        SkinShuffleCompatibility.handleSkinRefresh(player.getServer(), player, payload);
+    }
+}

neoforge/src/main/java/net/lionarius/skinrestorer/neoforge/platform/NeoForgeCompatibilityHelper.java

@@ -0,0 +1,15 @@
+package net.lionarius.skinrestorer.neoforge.platform;
+
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleHandshakePayload;
+import net.lionarius.skinrestorer.platform.services.CompatibilityHelper;
+import net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket;
+import net.minecraft.server.level.ServerPlayer;
+
+public final class NeoForgeCompatibilityHelper implements CompatibilityHelper {
+    
+    @Override
+    public void skinShuffle_sendHandshake(ServerPlayer player) {
+        // we can't use the packet distributor here because neoforge doesn't support sending packets to non-neoforge players
+        player.connection.connection.send(new ClientboundCustomPayloadPacket(SkinShuffleHandshakePayload.INSTANCE));
+    }
+}

neoforge/src/main/resources/META-INF/services/net.lionarius.skinrestorer.platform.services.CompatibilityHelper

@@ -0,0 +1 @@
+net.lionarius.skinrestorer.neoforge.platform.NeoForgeCompatibilityHelper

settings.gradle

@@ -71,4 +71,4 @@ rootProject.name = 'skin-restorer'
 include('common')
 include('fabric')
 include('forge')
-include('neoforge')
+//include('neoforge')