Update version to 5.0.0 for release

* Improved Wrapping of PlayerInfoData and support chat session data
* added constructor for unambiguous creation of playerinfodata without signature

.github/workflows/build.yml

@@ -15,14 +15,14 @@ jobs:
         uses: actions/setup-java@v3
         with:
           distribution: 'temurin'
-          java-version: '17'
-          cache: 'maven'
+          java-version: '19'
+          cache: 'gradle'
 
-      - name: Run maven build lifecycle
-        run: mvn --batch-mode clean test package
+      - name: Run gradle build lifecycle
+        run: ./gradlew build shadowJar --no-daemon
 
       - name: Upload plugin file
         uses: actions/upload-artifact@v2
         with:
           name: ProtocolLib
-          path: target/ProtocolLib.jar
+          path: build/libs/ProtocolLib.jar

.github/workflows/codeql-analysis.yml

@@ -26,16 +26,16 @@ jobs:
         uses: actions/setup-java@v3
         with:
           distribution: 'temurin'
-          java-version: '17'
-          cache: 'maven'
+          java-version: '19'
+          cache: 'gradle'
 
       - name: Initialize CodeQL
         uses: github/codeql-action/init@v2
         with:
           languages: 'java'
 
-      - name: Run maven build lifecycle
-        run: mvn --batch-mode clean test package
+      - name: Run gradle build lifecycle
+        run: ./gradlew build -x test --no-daemon
 
       - name: Perform CodeQL Analysis
         uses: github/codeql-action/analyze@v2

Readme.md

@@ -10,8 +10,6 @@ Critically, different plugins that use this approach may _hook_ into the same cl
 with unpredictable outcomes. More than often this causes plugins to crash, but it may also
 lead to more subtle bugs.
 
-Currently maintained by dmulloy2 on behalf of [Spigot](https://www.spigotmc.org/).
-
 ### Resources
 
 * [Resource Page](https://www.spigotmc.org/resources/protocollib.1997/)
@@ -20,8 +18,10 @@ Currently maintained by dmulloy2 on behalf of [Spigot](https://www.spigotmc.org/
 
 ### Compilation
 
-ProtocolLib is built with [Maven](https://maven.apache.org/). If you have it installed, just run
-`mvn package` in the root project folder.
+ProtocolLib is built with [Gradle](https://gradle.org/). If you have it installed, just run
+`./gradlew build` in the root project folder. Other gradle targets you may be interested in 
+include `clean`, `test`, and `shadowJar`. `shadowJar` will create a jar with all dependencies
+(ByteBuddy) included.
 
 ### A new API
 
@@ -53,7 +53,7 @@ You can also add ProtocolLib as a Maven dependency:
   <dependency>
     <groupId>com.comphenix.protocol</groupId>
     <artifactId>ProtocolLib</artifactId>
-    <version>4.7.0</version>
+    <version>5.0.0</version>
     <scope>provided</scope>
   </dependency>
 </dependencies>
@@ -67,7 +67,7 @@ repositories {
 }
 
 dependencies {
-    compileOnly group: "com.comphenix.protocol", name: "ProtocolLib", version: "4.7.0";
+    compileOnly 'com.comphenix.protocol:ProtocolLib:5.0.0'
 }
 ```
 

TinyProtocol/src/main/java/com/comphenix/tinyprotocol/Reflection.java

@@ -3,6 +3,8 @@ package com.comphenix.tinyprotocol;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -177,6 +179,31 @@ public final class Reflection {
 		throw new IllegalArgumentException("Cannot find field with type " + fieldType);
 	}
 
+	/**
+	 * Retrieves a field with a given type and parameters. This is most useful
+	 * when dealing with Collections.
+	 *
+	 * @param target the target class.
+	 * @param fieldType Type of the field
+	 * @param params Variable length array of type parameters
+	 * @return The field
+	 *
+	 * @throws IllegalArgumentException If the field cannot be found
+	 */
+	public static Field getParameterizedField(Class<?> target, Class<?> fieldType, Class<?>... params) {
+		for (Field field : target.getDeclaredFields()) {
+			if (field.getType().equals(fieldType)) {
+				Type type = field.getGenericType();
+				if (type instanceof ParameterizedType) {
+					if (Arrays.equals(((ParameterizedType) type).getActualTypeArguments(), params))
+						return field;
+				}
+			}
+		}
+
+		throw new IllegalArgumentException("Unable to find a field with type " + fieldType + " and params " + Arrays.toString(params));
+	}
+
 	/**
 	 * Search for the first publicly and privately defined method of the given name and parameter count.
 	 * 
@@ -301,6 +328,23 @@ public final class Reflection {
 		return clazz;
 	}
 
+	/**
+	 * Retrieve a class from its full name with alternatives, without knowing its type on compile time.
+	 * <p>
+	 * This is useful when looking up fields by a NMS or OBC type.
+	 * <p>
+	 * 
+	 * @see {@link #getClass()} for more information.
+	 * @param lookupName - the class name with variables.
+	 * @param aliases - alternative names for this class.
+	 * @return The class.
+	 */
+	public static Class<Object> getUntypedClass(String lookupName, String... aliases) {
+		@SuppressWarnings({ "rawtypes", "unchecked" })
+		Class<Object> clazz = (Class) getClass(lookupName, aliases);
+		return clazz;
+	}
+
 	/**
 	 * Retrieve a class from its full name.
 	 * <p>
@@ -333,6 +377,61 @@ public final class Reflection {
 		return getCanonicalClass(expandVariables(lookupName));
 	}
 
+	/**
+	 * Retrieve the first class that matches the full class name.
+	 * <p>
+	 * Strings enclosed with curly brackets - such as {TEXT} - will be replaced according to the following table:
+	 * <p>
+	 * <table border="1">
+	 * <tr>
+	 * <th>Variable</th>
+	 * <th>Content</th>
+	 * </tr>
+	 * <tr>
+	 * <td>{nms}</td>
+	 * <td>Actual package name of net.minecraft.server.VERSION</td>
+	 * </tr>
+	 * <tr>
+	 * <td>{obc}</td>
+	 * <td>Actual pacakge name of org.bukkit.craftbukkit.VERSION</td>
+	 * </tr>
+	 * <tr>
+	 * <td>{version}</td>
+	 * <td>The current Minecraft package VERSION, if any.</td>
+	 * </tr>
+	 * </table>
+	 * 
+	 * @param lookupName - the class name with variables.
+	 * @param aliases - alternative names for this class.
+	 * @return Class object.
+	 * @throws RuntimeException If we are unable to find any of the given classes.
+	 */
+	public static Class<?> getClass(String lookupName, String... aliases) {
+		try {
+			// Try the main class first
+			return getClass(lookupName);
+		} catch (RuntimeException e) {
+			Class<?> success = null;
+
+			// Try every alias too
+			for (String alias : aliases) {
+				try {
+					success = getClass(alias);
+					break;
+				} catch (RuntimeException e1) {
+					// e1.printStackTrace();
+				}
+			}
+
+			if (success != null) {
+				return success;
+			} else {
+				// Hack failed
+				throw new RuntimeException(String.format("Unable to find %s (%s)", lookupName, String.join(",", aliases)));
+			}
+		}
+	}
+
 	/**
 	 * Retrieve a class in the net.minecraft.server.VERSION.* package.
 	 * 

TinyProtocol/src/main/java/com/comphenix/tinyprotocol/TinyProtocol.java

@@ -9,6 +9,7 @@ import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.ChannelPromise;
 
+import java.lang.reflect.Field;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -44,21 +45,25 @@ import com.mojang.authlib.GameProfile;
 public abstract class TinyProtocol {
 	private static final AtomicInteger ID = new AtomicInteger(0);
 
+	// Required Minecraft classes
+	private static final Class<?> entityPlayerClass = Reflection.getClass("{nms}.EntityPlayer", "net.minecraft.server.level.EntityPlayer");
+	private static final Class<?> playerConnectionClass = Reflection.getClass("{nms}.PlayerConnection", "net.minecraft.server.network.PlayerConnection");
+	private static final Class<?> networkManagerClass = Reflection.getClass("{nms}.NetworkManager", "net.minecraft.network.NetworkManager");
+
 	// Used in order to lookup a channel
 	private static final MethodInvoker getPlayerHandle = Reflection.getMethod("{obc}.entity.CraftPlayer", "getHandle");
-	private static final FieldAccessor<Object> getConnection = Reflection.getField("{nms}.EntityPlayer", "playerConnection", Object.class);
-	private static final FieldAccessor<Object> getManager = Reflection.getField("{nms}.PlayerConnection", "networkManager", Object.class);
-	private static final FieldAccessor<Channel> getChannel = Reflection.getField("{nms}.NetworkManager", Channel.class, 0);
+	private static final FieldAccessor<?> getConnection = Reflection.getField(entityPlayerClass, null, playerConnectionClass);
+	private static final FieldAccessor<?> getManager = Reflection.getField(playerConnectionClass, null, networkManagerClass);
+	private static final FieldAccessor<Channel> getChannel = Reflection.getField(networkManagerClass, Channel.class, 0);
 
 	// Looking up ServerConnection
-	private static final Class<Object> minecraftServerClass = Reflection.getUntypedClass("{nms}.MinecraftServer");
-	private static final Class<Object> serverConnectionClass = Reflection.getUntypedClass("{nms}.ServerConnection");
+	private static final Class<Object> minecraftServerClass = Reflection.getUntypedClass("{nms}.MinecraftServer", "net.minecraft.server.MinecraftServer");
+	private static final Class<Object> serverConnectionClass = Reflection.getUntypedClass("{nms}.ServerConnection", "net.minecraft.server.network.ServerConnection");
 	private static final FieldAccessor<Object> getMinecraftServer = Reflection.getField("{obc}.CraftServer", minecraftServerClass, 0);
 	private static final FieldAccessor<Object> getServerConnection = Reflection.getField(minecraftServerClass, serverConnectionClass, 0);
-	private static final MethodInvoker getNetworkMarkers = Reflection.getTypedMethod(serverConnectionClass, null, List.class, serverConnectionClass);
 
 	// Packets we have to intercept
-	private static final Class<?> PACKET_LOGIN_IN_START = Reflection.getMinecraftClass("PacketLoginInStart");
+	private static final Class<?> PACKET_LOGIN_IN_START = Reflection.getClass("{nms}.PacketLoginInStart", "net.minecraft.network.protocol.login.PacketLoginInStart");
 	private static final FieldAccessor<GameProfile> getGameProfile = Reflection.getField(PACKET_LOGIN_IN_START, GameProfile.class, 0);
 
 	// Speedup channel lookup
@@ -199,8 +204,22 @@ public abstract class TinyProtocol {
 		Object serverConnection = getServerConnection.get(mcServer);
 		boolean looking = true;
 
+		try {
+			Field field = Reflection.getParameterizedField(serverConnectionClass, List.class, networkManagerClass);
+			field.setAccessible(true);
+
+			networkManagers = (List<Object>) field.get(serverConnection);
+		} catch (Exception ex) {
+			plugin.getLogger().info("Encountered an exception checking list fields" + ex);
+			MethodInvoker method = Reflection.getTypedMethod(serverConnectionClass, null, List.class, serverConnectionClass);
+
+			networkManagers = (List<Object>) method.invoke(null, serverConnection);
+		}
+
+		if (networkManagers == null) {
+			throw new IllegalArgumentException("Failed to obtain list of network managers");
+		}
 		// We need to synchronize against this list
-		networkManagers = (List<Object>) getNetworkMarkers.invoke(null, serverConnection);
 		createServerChannelHandler();
 
 		// Find the correct list, or implicitly throw an exception

build.gradle

@@ -0,0 +1,114 @@
+plugins {
+    id 'java-library'
+    id 'maven-publish'
+    id 'com.github.johnrengelman.shadow' version '8.1.1'
+}
+
+group = 'com.comphenix.protocol'
+version = '5.0.0'
+description = 'Provides access to the Minecraft protocol'
+
+def isSnapshot = version.endsWith('-SNAPSHOT')
+
+repositories {
+    // mavenLocal() // can speed up build, but may fail in CI
+    mavenCentral()
+
+    maven {
+        url 'https://repo.dmulloy2.net/repository/public/'
+    }
+
+    maven {
+        url 'https://hub.spigotmc.org/nexus/content/groups/public/'
+    }
+
+    maven {
+        url 'https://libraries.minecraft.net/'
+        metadataSources {
+            mavenPom()
+            artifact()
+            ignoreGradleMetadataRedirection()
+        }
+    }
+}
+
+dependencies {
+    implementation 'net.bytebuddy:byte-buddy:1.14.3'
+    compileOnly 'org.spigotmc:spigot-api:1.19.4-R0.1-SNAPSHOT'
+    compileOnly 'org.spigotmc:spigot:1.19.4-R0.1-SNAPSHOT'
+    compileOnly 'io.netty:netty-all:4.0.23.Final'
+    compileOnly 'net.kyori:adventure-text-serializer-gson:4.13.0'
+    compileOnly 'com.googlecode.json-simple:json-simple:1.1.1'
+
+    testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.9.2'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.2'
+    testImplementation 'org.mockito:mockito-core:4.11.0'
+    testImplementation 'org.mockito:mockito-inline:4.11.0'
+    testImplementation 'io.netty:netty-common:4.1.77.Final'
+    testImplementation 'io.netty:netty-transport:4.1.77.Final'
+    testImplementation 'org.spigotmc:spigot:1.19.4-R0.1-SNAPSHOT'
+    testImplementation 'net.kyori:adventure-text-serializer-gson:4.13.0'
+    testImplementation 'net.kyori:adventure-text-serializer-plain:4.13.1'
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+
+    withJavadocJar()
+    withSourcesJar()
+}
+
+shadowJar {
+    dependencies {
+        include(dependency('net.bytebuddy:byte-buddy:.*'))
+    }
+    relocate 'net.bytebuddy', 'com.comphenix.net.bytebuddy'
+    archiveFileName = 'ProtocolLib.jar'
+}
+
+test {
+    useJUnitPlatform()
+}
+
+processResources {
+    def includeBuild = isSnapshot && System.getenv('BUILD_NUMBER')
+    def fullVersion = includeBuild
+        ? version + '-' + System.getenv('BUILD_NUMBER')
+        : version
+
+    eachFile { expand(['version': fullVersion]) }
+}
+
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            from components.java
+
+            afterEvaluate {
+                artifactId = 'ProtocolLib'
+            }
+        }
+    }
+
+    repositories {
+        maven {
+            url isSnapshot
+                ? 'https://repo.dmulloy2.net/repository/snapshots/'
+                : 'https://repo.dmulloy2.net/repository/releases/'
+
+            credentials {
+                username project.nexusUsername
+                password project.nexusPassword
+            }
+        }
+    }
+}
+
+tasks.withType(JavaCompile) {
+    options.encoding = 'UTF-8'
+}
+
+tasks.withType(Javadoc) {
+    options.encoding = 'UTF-8'
+}

gradle.properties

@@ -0,0 +1,2 @@
+nexusUsername=""
+nexusPassword=""

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.2-bin.zip
+networkTimeout=10000
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,244 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,92 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

pom.xml

@@ -1,379 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-	<groupId>com.comphenix.protocol</groupId>
-	<artifactId>ProtocolLib</artifactId>
-	<name>ProtocolLib</name>
-	<version>5.0.0-SNAPSHOT</version>
-
-	<description>Provides read/write access to the Minecraft protocol.</description>
-	<url>https://github.com/dmulloy2/ProtocolLib</url>
-	<packaging>jar</packaging>
-	<inceptionYear>2012</inceptionYear>
-
-	<properties>
-		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<project.build.number></project.build.number>
-		<project.fullVersion>${project.version}</project.fullVersion>
-
-		<junit.version>5.9.2</junit.version>
-		<mockito.version>4.11.0</mockito.version>
-		<netty.version>4.1.77.Final</netty.version>
-		<spigot.version>1.19.4-R0.1-SNAPSHOT</spigot.version>
-	</properties>
-
-	<build>
-		<defaultGoal>clean install</defaultGoal>
-		<sourceDirectory>src/main/java</sourceDirectory>
-		<testSourceDirectory>src/test/java</testSourceDirectory>
-		<resources>
-			<resource>
-				<directory>src/main/resources</directory>
-				<filtering>true</filtering>
-				<excludes>
-					<exclude>**/*.java</exclude>
-				</excludes>
-			</resource>
-		</resources>
-
-		<plugins>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-shade-plugin</artifactId>
-				<version>3.4.1</version>
-				<executions>
-					<execution>
-						<phase>package</phase>
-						<goals>
-							<goal>shade</goal>
-						</goals>
-						<configuration>
-							<shadedArtifactAttached>false</shadedArtifactAttached>
-							<createDependencyReducedPom>false</createDependencyReducedPom>
-
-							<relocations>
-								<relocation>
-									<pattern>net.bytebuddy</pattern>
-									<shadedPattern>com.comphenix.net.bytebuddy</shadedPattern>
-								</relocation>
-							</relocations>
-
-							<artifactSet>
-								<excludes>
-									<exclude>org.spigotmc:spigot</exclude>
-									<exclude>org.spigotmc:spigot-api</exclude>
-									<exclude>junit:junit</exclude>
-									<exclude>io.netty:*</exclude>
-								</excludes>
-							</artifactSet>
-						</configuration>
-					</execution>
-				</executions>
-			</plugin>
-
-			<plugin>
-				<artifactId>maven-compiler-plugin</artifactId>
-				<version>3.11.0</version>
-				<configuration>
-					<source>1.8</source>
-					<target>1.8</target>
-				</configuration>
-			</plugin>
-
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-jar-plugin</artifactId>
-				<version>3.3.0</version>
-				<configuration>
-					<archive>
-						<manifestEntries>
-							<Main-Class>com.comphenix.protocol.Application</Main-Class>
-							<Implementation-Title>ProtocolLib</Implementation-Title>
-							<Implementation-Version>${project.fullVersion}</Implementation-Version>
-							<Implementation-Vendor>dmulloy2</Implementation-Vendor>
-						</manifestEntries>
-					</archive>
-					<finalName>${project.name}</finalName>
-				</configuration>
-			</plugin>
-
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.0.0</version>
-				<dependencies>
-					<!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-engine -->
-					<dependency>
-						<groupId>org.junit.jupiter</groupId>
-						<artifactId>junit-jupiter-engine</artifactId>
-						<version>${junit.version}</version>
-					</dependency>
-				</dependencies>
-				<configuration>
-					<trimStackTrace>false</trimStackTrace>
-					<useFile>false</useFile>
-					<systemProperties>
-						<property>
-							<name>projectVersion</name>
-							<value>${project.version}</value>
-						</property>
-					</systemProperties>
-					<!-- We need this as we use reflection in tests to ensure equality -->
-					<argLine>--add-opens java.base/java.util=ALL-UNNAMED</argLine>
-				</configuration>
-			</plugin>
-
-			<plugin>
-				<artifactId>maven-javadoc-plugin</artifactId>
-				<version>3.5.0</version>
-				<configuration>
-					<failOnError>false</failOnError>
-					<encoding>ISO-8859-1</encoding>
-					<doctitle>ProtocolLib JavaDocs</doctitle>
-					<windowtitle>ProtocolLib JavaDocs</windowtitle>
-					<bottom>Copyright &#169; {inceptionYear}&#x2013;{currentYear}
-						Comphenix and dmulloy2. Licensed under the GNU GPL v2.
-					</bottom>
-					<additionalOptions>
-						<additionalOption>-Xdoclint:none</additionalOption>
-					</additionalOptions>
-				</configuration>
-				<executions>
-					<execution>
-						<phase>install</phase>
-						<goals>
-							<goal>aggregate</goal>
-						</goals>
-					</execution>
-				</executions>
-			</plugin>
-		</plugins>
-	</build>
-
-	<profiles>
-		<profile>
-			<id>jenkins</id>
-			<activation>
-				<property>
-					<name>env.BUILD_NUMBER</name>
-				</property>
-			</activation>
-			<properties>
-				<project.build.number>-b${env.BUILD_NUMBER}</project.build.number>
-				<project.fullVersion>${project.version}${project.build.number}</project.fullVersion>
-				<!--<project.fullVersion>${project.version}</project.fullVersion>-->
-			</properties>
-		</profile>
-
-		<profile>
-			<id>release-sign-artifacts</id>
-			<activation>
-				<property>
-					<name>performRelease</name>
-					<value>true</value>
-				</property>
-			</activation>
-			<properties>
-				<project.fullVersion>${project.version}</project.fullVersion>
-			</properties>
-			<build>
-				<plugins>
-					<plugin>
-						<groupId>org.apache.maven.plugins</groupId>
-						<artifactId>maven-source-plugin</artifactId>
-						<version>3.2.1</version>
-						<executions>
-							<execution>
-								<id>attach-sources</id>
-								<goals>
-									<goal>jar</goal>
-								</goals>
-							</execution>
-						</executions>
-					</plugin>
-
-					<plugin>
-						<groupId>org.apache.maven.plugins</groupId>
-						<artifactId>maven-javadoc-plugin</artifactId>
-						<version>3.4.0</version>
-						<executions>
-							<execution>
-								<id>attach-javadocs</id>
-								<goals>
-									<goal>jar</goal>
-								</goals>
-							</execution>
-						</executions>
-					</plugin>
-
-					<!-- TODO: Look into signing releases
-					<plugin>
-						<groupId>org.apache.maven.plugins</groupId>
-						<artifactId>maven-gpg-plugin</artifactId>
-						<version>1.6</version>
-						<executions>
-							<execution>
-								<id>sign-artifacts</id>
-								<phase>verify</phase>
-								<goals>
-									<goal>sign</goal>
-								</goals>
-							</execution>
-						</executions>
-					</plugin>
-					-->
-
-				</plugins>
-			</build>
-		</profile>
-	</profiles>
-
-	<scm>
-		<connection>scm:git:git://github.com/dmulloy2/ProtocolLib.git</connection>
-		<developerConnection>scm:git:git@github.com:dmulloy2/ProtocolLib.git</developerConnection>
-		<url>https://github.com/dmulloy2/ProtocolLib</url>
-	</scm>
-
-	<licenses>
-		<license>
-			<name>GNU GENERAL PUBLIC LICENSE - Version 2, June 1991</name>
-			<url>https://www.gnu.org/licenses/gpl-2.0.txt</url>
-			<distribution>repo</distribution>
-		</license>
-	</licenses>
-
-	<developers>
-		<developer>
-			<id>dmulloy2</id>
-			<name>Dan Mulloy</name>
-			<url>https://dmulloy2.net/</url>
-			<roles>
-				<role>developer</role>
-				<role>maintainer</role>
-			</roles>
-		</developer>
-		<developer>
-			<id>aadnk</id>
-			<name>Kristian S. Stangeland</name>
-			<email>kr_stang@hotmail.com</email>
-			<url>https://comphenix.net/</url>
-			<roles>
-				<role>former author</role>
-			</roles>
-			<timezone>1</timezone>
-		</developer>
-	</developers>
-
-	<distributionManagement>
-		<repository>
-			<id>dmulloy2-releases</id>
-			<url>https://repo.dmulloy2.net/repository/releases/</url>
-		</repository>
-		<snapshotRepository>
-			<id>dmulloy2-snapshots</id>
-			<url>https://repo.dmulloy2.net/repository/snapshots/</url>
-		</snapshotRepository>
-	</distributionManagement>
-
-	<repositories>
-		<repository>
-			<id>dmulloy2-repo</id>
-			<url>https://repo.dmulloy2.net/repository/public/</url>
-		</repository>
-		<repository>
-			<id>spigot-repo</id>
-			<url>https://hub.spigotmc.org/nexus/content/groups/public/</url>
-		</repository>
-	</repositories>
-
-	<dependencies>
-		<!-- core minecraft dependencies -->
-		<dependency>
-			<groupId>org.spigotmc</groupId>
-			<artifactId>spigot-api</artifactId>
-			<version>${spigot.version}</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>junit</groupId>
-					<artifactId>*</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-		<dependency>
-			<groupId>org.spigotmc</groupId>
-			<artifactId>spigot</artifactId>
-			<version>${spigot.version}</version>
-			<scope>provided</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>junit</groupId>
-					<artifactId>*</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>io.netty</groupId>
-					<artifactId>*</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<!-- Compile with the old version of Netty for backwards compat -->
-		<!-- https://mvnrepository.com/artifact/io.netty/netty-all -->
-		<dependency>
-			<groupId>io.netty</groupId>
-			<artifactId>netty-all</artifactId>
-			<version>4.0.23.Final</version>
-			<scope>provided</scope>
-		</dependency>
-		<!-- https://mvnrepository.com/artifact/net.kyori/adventure-text-serializer-gson -->
-		<dependency>
-			<groupId>net.kyori</groupId>
-			<artifactId>adventure-text-serializer-gson</artifactId>
-			<version>4.13.0</version>
-			<scope>provided</scope>
-		</dependency>
-		<!-- https://mvnrepository.com/artifact/net.bytebuddy/byte-buddy -->
-		<dependency>
-			<groupId>net.bytebuddy</groupId>
-			<artifactId>byte-buddy</artifactId>
-			<version>1.14.3</version>
-		</dependency>
-
-		<!-- Testing dependencies -->
-		<!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-engine -->
-		<dependency>
-			<groupId>org.junit.jupiter</groupId>
-			<artifactId>junit-jupiter-api</artifactId>
-			<version>${junit.version}</version>
-			<scope>test</scope>
-		</dependency>
-		<!-- https://mvnrepository.com/artifact/org.mockito/mockito-core -->
-		<dependency>
-			<groupId>org.mockito</groupId>
-			<artifactId>mockito-core</artifactId>
-			<version>${mockito.version}</version>
-			<scope>test</scope>
-		</dependency>
-		<!-- https://mvnrepository.com/artifact/org.mockito/mockito-inline -->
-		<dependency>
-			<groupId>org.mockito</groupId>
-			<artifactId>mockito-inline</artifactId>
-			<version>${mockito.version}</version>
-			<scope>test</scope>
-		</dependency>
-		<!-- https://mvnrepository.com/artifact/io.netty/netty-common -->
-		<dependency>
-			<groupId>io.netty</groupId>
-			<artifactId>netty-common</artifactId>
-			<version>${netty.version}</version>
-			<scope>test</scope>
-		</dependency>
-		<!-- https://mvnrepository.com/artifact/io.netty/netty-transport -->
-		<dependency>
-			<groupId>io.netty</groupId>
-			<artifactId>netty-transport</artifactId>
-			<version>${netty.version}</version>
-			<scope>test</scope>
-		</dependency>
-	</dependencies>
-</project>

settings.gradle

@@ -0,0 +1,5 @@
+/*
+ * This file was generated by the Gradle 'init' task.
+ */
+
+rootProject.name = 'ProtocolLib'

src/main/java/com/comphenix/protocol/events/AbstractStructure.java

@@ -29,6 +29,7 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.MerchantRecipe;
 import org.bukkit.potion.PotionEffectType;
 import org.bukkit.util.Vector;
+import org.jetbrains.annotations.NotNull;
 
 public abstract class AbstractStructure {
     protected transient Object handle;
@@ -308,6 +309,31 @@ public abstract class AbstractStructure {
                 BlockPosition.getConverter());
     }
 
+    /**
+     * Retrieves a read/write structure for registrable objects.
+     *
+     * @param registrableClass The registrable object's class.
+     * @return A modifier for a registrable objects.
+     * @see MinecraftReflection#getBlockEntityTypeClass()
+     */
+    public StructureModifier<WrappedRegistrable> getRegistrableModifier(
+        @NotNull final Class<?> registrableClass
+    ) {
+        // Convert to and from the Bukkit wrapper
+        return structureModifier.withType(
+            registrableClass,
+            BukkitConverters.getWrappedRegistrable(registrableClass));
+    }
+
+    /**
+     * Retrieves a read/write structure for BlockEntityType.
+     * @return A modifier for a BlockEntityType.
+     */
+    public StructureModifier<WrappedRegistrable> getBlockEntityTypeModifier() {
+        // Convert to and from the Bukkit wrapper
+        return getRegistrableModifier(MinecraftReflection.getBlockEntityTypeClass());
+    }
+
     /**
      * Retrieves a read/write structure for wrapped ChunkCoordIntPairs.
      * @return A modifier for ChunkCoordIntPair.
@@ -961,7 +987,7 @@ public abstract class AbstractStructure {
     }
 
     /**
-     * Retrieve a read/write structure for profile public keys in 1.9
+     * Retrieve a read/write structure for profile public keys in 1.19
      * @return The Structure Modifier
      */
     public StructureModifier<WrappedProfilePublicKey> getProfilePublicKeys() {
@@ -971,13 +997,24 @@ public abstract class AbstractStructure {
     }
 
     /**
-     * Retrieve a read/write structure for profile public key data in 1.9
+     * Retrieve a read/write structure for profile public key data in 1.19
      * @return The Structure Modifier
      */
     public StructureModifier<WrappedProfileKeyData> getProfilePublicKeyData() {
         return structureModifier.withType(
-            MinecraftReflection.getProfilePublicKeyDataClass(),
-            BukkitConverters.getWrappedPublicKeyDataConverter());
+                MinecraftReflection.getProfilePublicKeyDataClass(),
+                BukkitConverters.getWrappedPublicKeyDataConverter());
+    }
+
+    /**
+     * Retrieves read/write structure for remote chat session data in 1.19.3
+     * @return The Structure Modifier
+     */
+    public StructureModifier<WrappedRemoteChatSessionData> getRemoteChatSessionData() {
+        return structureModifier.withType(
+                MinecraftReflection.getRemoteChatSessionDataClass(),
+                BukkitConverters.getWrappedRemoteChatSessionDataConverter()
+        );
     }
 
     /**
@@ -1006,7 +1043,7 @@ public abstract class AbstractStructure {
     }
 
     /**
-     * @return read/writer structure direct access to signature data like chat messages
+     * @return read/writer structure direct access to salted signature data like chat messages
      */
     public StructureModifier<WrappedSaltedSignature> getSignatures() {
         return structureModifier.withType(
@@ -1015,6 +1052,16 @@ public abstract class AbstractStructure {
         );
     }
 
+    /**
+     * @return read/writer structure direct access to unsalted signature data for example in chat message (since 1.19.3)
+     */
+    public StructureModifier<WrappedMessageSignature> getMessageSignatures() {
+        return structureModifier.withType(
+                MinecraftReflection.getMessageSignatureClass(),
+                BukkitConverters.getWrappedMessageSignatureConverter()
+        );
+    }
+
     /**
      * @param leftConverter converter for left values
      * @param rightConverter converter for right values

src/main/java/com/comphenix/protocol/events/PacketEvent.java

@@ -92,6 +92,9 @@ public class PacketEvent extends EventObject implements Cancellable {
 	private PacketEvent(Object source, PacketContainer packet, NetworkMarker marker, Player player, boolean serverPacket,
 			boolean filtered, @Nullable PacketEvent bundleEvent) {
 		super(source);
+		if(packet == null) {
+			throw new IllegalArgumentException("packet cannot be null");
+		}
 		this.packet = packet;
 		this.playerReference = new WeakReference<>(player);
 		this.networkMarker = marker;

src/main/java/com/comphenix/protocol/events/PacketOutputHandler.java

@@ -28,7 +28,7 @@ public interface PacketOutputHandler {
 	 * Note that the buffer is initially filled with the output from the default write method.
 	 * <p>
 	 * In Minecraft 1.6.4, the header is always excluded, whereas it MUST be included in Minecraft 1.7.2. Call 
-	 * {@link NetworkMarker#requireOutputHeader()} to determine this.
+	 * NetworkMarker#requireOutputHeader() to determine this.
 	 * @param event - the packet that will be outputted.
 	 * @param buffer - the data that is currently scheduled to be outputted.
 	 * @return The modified byte array to write. NULL is not permitted.

src/main/java/com/comphenix/protocol/injector/PacketFilterManager.java

@@ -3,6 +3,7 @@ package com.comphenix.protocol.injector;
 import com.comphenix.protocol.AsynchronousManager;
 import com.comphenix.protocol.PacketType;
 import com.comphenix.protocol.PacketType.Sender;
+import com.comphenix.protocol.ProtocolLibrary;
 import com.comphenix.protocol.async.AsyncFilterManager;
 import com.comphenix.protocol.error.ErrorReporter;
 import com.comphenix.protocol.error.Report;
@@ -32,6 +33,8 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
+import java.util.logging.Level;
+
 import org.bukkit.Location;
 import org.bukkit.Server;
 import org.bukkit.World;
@@ -541,25 +544,29 @@ public class PacketFilterManager implements ListenerInvoker, InternalManager {
 	}
 
 	private void postPacketToListeners(SortedPacketListenerList listeners, PacketEvent event, boolean outbound) {
-		// append async marker if any async listener for the packet was registered
-		if (this.asyncFilterManager.hasAsynchronousListeners(event)) {
-			event.setAsyncMarker(this.asyncFilterManager.createAsyncMarker());
-		}
+		try {
+			// append async marker if any async listener for the packet was registered
+			if (this.asyncFilterManager.hasAsynchronousListeners(event)) {
+				event.setAsyncMarker(this.asyncFilterManager.createAsyncMarker());
+			}
 
-		// post to sync listeners
-		if (outbound) {
-			listeners.invokePacketSending(this.reporter, event);
-		} else {
-			listeners.invokePacketRecieving(this.reporter, event);
-		}
+			// post to sync listeners
+			if (outbound) {
+				listeners.invokePacketSending(this.reporter, event);
+			} else {
+				listeners.invokePacketRecieving(this.reporter, event);
+			}
 
-		// check if we need to post the packet to the async handler
-		if (!event.isCancelled() && event.getAsyncMarker() != null && !event.getAsyncMarker().isAsyncCancelled()) {
-			this.asyncFilterManager.enqueueSyncPacket(event, event.getAsyncMarker());
+			// check if we need to post the packet to the async handler
+			if (!event.isCancelled() && event.getAsyncMarker() != null && !event.getAsyncMarker().isAsyncCancelled()) {
+				this.asyncFilterManager.enqueueSyncPacket(event, event.getAsyncMarker());
 
-			// cancel the packet here for async processing (enqueueSyncPacket will create a copy of the event)
-			event.setReadOnly(false);
-			event.setCancelled(true);
+				// cancel the packet here for async processing (enqueueSyncPacket will create a copy of the event)
+				event.setReadOnly(false);
+				event.setCancelled(true);
+			}
+		} catch (Throwable t) {
+			plugin.getLogger().log(Level.WARNING, "Failed to process " + (outbound ? "outbound" : "inbound") + " packet event: " + event, t);
 		}
 	}
 

src/main/java/com/comphenix/protocol/injector/SortedPacketListenerList.java

@@ -20,16 +20,16 @@ package com.comphenix.protocol.injector;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.logging.Level;
 
 import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolLibrary;
 import com.comphenix.protocol.concurrency.AbstractConcurrentListenerMultimap;
 import com.comphenix.protocol.error.ErrorReporter;
 import com.comphenix.protocol.events.ListenerPriority;
 import com.comphenix.protocol.events.PacketContainer;
 import com.comphenix.protocol.events.PacketEvent;
 import com.comphenix.protocol.events.PacketListener;
-import com.comphenix.protocol.injector.packet.PacketRegistry;
-import com.comphenix.protocol.reflect.StructureModifier;
 import com.comphenix.protocol.timing.TimedListenerManager;
 import com.comphenix.protocol.timing.TimedListenerManager.ListenerType;
 import com.comphenix.protocol.timing.TimedTracker;
@@ -152,12 +152,23 @@ public final class SortedPacketListenerList extends AbstractConcurrentListenerMu
 			Iterable<PacketContainer> packets = event.getPacket().getPacketBundles().read(0);
 			List<PacketContainer> outPackets = new ArrayList<>();
 			for (PacketContainer subPacket : packets) {
+				if(subPacket == null) {
+					ProtocolLibrary.getPlugin().getLogger().log(Level.WARNING, "Failed to invoke packet event " + (priorityFilter == null ? "" : ("with priority " + priorityFilter)) + " in bundle because bundle contains null packet: " + packets, new Throwable());
+					continue;
+				}
 				PacketEvent subPacketEvent = PacketEvent.fromServer(this, subPacket, event.getNetworkMarker(), event.getPlayer());
 				invokeUnpackedPacketSending(reporter, subPacketEvent, priorityFilter);
 
 				if (!subPacketEvent.isCancelled()) {
 					// if the packet event has been cancelled, the packet will be removed from the bundle
-					outPackets.add(subPacketEvent.getPacket());
+					PacketContainer packet = subPacketEvent.getPacket();
+					if(packet == null) {
+						ProtocolLibrary.getPlugin().getLogger().log(Level.WARNING, "null packet container returned for " + subPacketEvent, new Throwable());
+					} else if(packet.getHandle() == null) {
+						ProtocolLibrary.getPlugin().getLogger().log(Level.WARNING, "null packet handle returned for " + subPacketEvent, new Throwable());
+					} else {
+						outPackets.add(packet);
+					}
 				}
 			}
 

src/main/java/com/comphenix/protocol/injector/packet/PacketRegistry.java

@@ -30,7 +30,6 @@ import com.comphenix.protocol.reflect.StructureModifier;
 import com.comphenix.protocol.reflect.fuzzy.FuzzyFieldContract;
 import com.comphenix.protocol.utility.MinecraftReflection;
 import com.comphenix.protocol.utility.MinecraftVersion;
-import com.comphenix.protocol.utility.Util;
 
 /**
  * Static packet registry in Minecraft.
@@ -252,10 +251,13 @@ public class PacketRegistry {
 
 	protected static void associatePackets(Register register, Map<Integer, Class<?>> lookup, PacketType.Protocol protocol, Sender sender) {
 		for (Map.Entry<Integer, Class<?>> entry : lookup.entrySet()) {
-			PacketType type = PacketType.fromCurrent(protocol, sender, entry.getKey(), entry.getValue());
+			int packetId = entry.getKey();
+			Class<?> packetClass = entry.getValue();
+
+			PacketType type = PacketType.fromCurrent(protocol, sender, packetId, packetClass);
 
 			try {
-				register.registerPacket(type, entry.getValue(), sender);
+				register.registerPacket(type, packetClass, sender);
 			} catch (Exception ex) {
 				ProtocolLogger.debug("Encountered an exception associating packet " + type, ex);
 			}
@@ -271,18 +273,28 @@ public class PacketRegistry {
 		}
 	}
 
+	private static final Object registryLock = new Object();
+
 	/**
 	 * Initializes the packet registry.
 	 */
 	private static void initialize() {
-		if (!INITIALIZED) {
-			INITIALIZED = true;
+		if (INITIALIZED) {
+			return;
+		}
+
+		synchronized (registryLock) {
+			if (INITIALIZED) {
+				return;
+			}
 
 			if (MinecraftVersion.BEE_UPDATE.atOrAbove()) {
 				REGISTER = createNewRegister();
 			} else {
 				REGISTER = createOldRegister();
 			}
+
+			INITIALIZED = true;
 		}
 	}
 
@@ -351,6 +363,9 @@ public class PacketRegistry {
 		// Try the lookup first (may be null, so check contains)
 		Optional<Class<?>> res = REGISTER.typeToClass.get(type);
 		if (res != null) {
+			if(res.isPresent() && MinecraftReflection.isBundleDelimiter(res.get())) {
+				return MinecraftReflection.getPackedBundlePacketClass();
+			}
 			return res;
 		}
 
@@ -363,6 +378,9 @@ public class PacketRegistry {
 
 		// cache it for next time
 		associate(type, clazz);
+		if(clazz != null && MinecraftReflection.isBundleDelimiter(clazz)) {
+			clazz = MinecraftReflection.getPackedBundlePacketClass().orElseThrow(() -> new IllegalStateException("Packet bundle class not found."));
+		}
 		return Optional.ofNullable(clazz);
 	}
 

src/main/java/com/comphenix/protocol/utility/MinecraftReflection.java

@@ -1573,6 +1573,10 @@ public final class MinecraftReflection {
 		return getMinecraftClass("world.entity.player.ProfilePublicKey");
 	}
 
+	public static Class<?> getMessageSignatureClass() {
+		return getMinecraftClass("network.chat.MessageSignature");
+	}
+
     public static Class<?> getSaltedSignatureClass() {
         try {
             return getMinecraftClass("SaltedSignature");
@@ -1621,6 +1625,10 @@ public final class MinecraftReflection {
 		return getMinecraftClass("network.chat.RemoteChatSession");
 	}
 
+	public static Class<?> getRemoteChatSessionDataClass() {
+		return getRemoteChatSessionClass().getClasses()[0];
+	}
+
 	public static Class<?> getFastUtilClass(String className) {
 		return getLibraryClass("it.unimi.dsi.fastutil." + className);
 	}
@@ -1685,6 +1693,22 @@ public final class MinecraftReflection {
 		}
 	}
 
+	public static Class<?> getDynamicOpsClass() {
+		return getLibraryClass("com.mojang.serialization.DynamicOps");
+	}
+
+	public static Class<?> getJsonOpsClass() {
+		return getLibraryClass("com.mojang.serialization.JsonOps");
+	}
+
+	public static Class<?> getNbtOpsClass() {
+		return getMinecraftClass("nbt.DynamicOpsNBT" /* Spigot Mappings */, "nbt.NbtOps" /* Mojang Mappings */);
+	}
+
+	public static Class<?> getCodecClass() {
+		return getLibraryClass("com.mojang.serialization.Codec");
+	}
+
     public static Class<?> getHolderClass() {
 		return getMinecraftClass("core.Holder");
     }

src/main/java/com/comphenix/protocol/wrappers/BukkitConverters.java

@@ -77,6 +77,7 @@ import org.bukkit.inventory.MerchantRecipe;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 import org.bukkit.util.Vector;
+import org.jetbrains.annotations.NotNull;
 
 import static com.comphenix.protocol.utility.MinecraftReflection.getCraftBukkitClass;
 import static com.comphenix.protocol.utility.MinecraftReflection.getMinecraftClass;
@@ -587,7 +588,23 @@ public class BukkitConverters {
 	public static EquivalentConverter<WrappedBlockData> getWrappedBlockDataConverter() {
 		return ignoreNull(handle(WrappedBlockData::getHandle, WrappedBlockData::fromHandle, WrappedBlockData.class));
 	}
-	
+
+	/**
+	 * Retrieve a converter for wrapped block entity type.
+	 * @return Wrapped block entity type.
+	 */
+	public static EquivalentConverter<WrappedRegistrable> getWrappedRegistrable(
+		@NotNull final Class<?> registrableClass
+	) {
+		return ignoreNull(
+			handle(
+				WrappedRegistrable::getHandle,
+				handle -> WrappedRegistrable.fromHandle(registrableClass, handle),
+				WrappedRegistrable.class
+			)
+		);
+	}
+
 	/**
 	 * Retrieve a converter for wrapped attribute snapshots.
 	 * @return Wrapped attribute snapshot converter.
@@ -604,6 +621,10 @@ public class BukkitConverters {
 		return ignoreNull(handle(WrappedProfileKeyData::getHandle, WrappedProfileKeyData::new, WrappedProfileKeyData.class));
 	}
 
+	public static EquivalentConverter<WrappedRemoteChatSessionData> getWrappedRemoteChatSessionDataConverter() {
+		return ignoreNull(handle(WrappedRemoteChatSessionData::getHandle, WrappedRemoteChatSessionData::new, WrappedRemoteChatSessionData.class));
+	}
+
 	/**
 	 * @return converter for cryptographic signature data that are used in login and chat packets
 	 */
@@ -611,6 +632,13 @@ public class BukkitConverters {
         return ignoreNull(handle(WrappedSaltedSignature::getHandle, WrappedSaltedSignature::new, WrappedSaltedSignature.class));
     }
 
+	/**
+	 * @return converter for an encoded cryptographic message signature
+	 */
+    public static EquivalentConverter<WrappedMessageSignature> getWrappedMessageSignatureConverter() {
+        return ignoreNull(handle(WrappedMessageSignature::getHandle, WrappedMessageSignature::new, WrappedMessageSignature.class));
+    }
+
 	public static EquivalentConverter<WrappedLevelChunkData.ChunkData> getWrappedChunkDataConverter() {
 		return ignoreNull(handle(WrappedLevelChunkData.ChunkData::getHandle, WrappedLevelChunkData.ChunkData::new, WrappedLevelChunkData.ChunkData.class));
 	}
@@ -620,7 +648,7 @@ public class BukkitConverters {
 	}
 
 	public static EquivalentConverter<PacketContainer> getPacketContainerConverter() {
-		return handle(PacketContainer::getHandle, PacketContainer::fromPacket, PacketContainer.class);
+		return ignoreNull(handle(PacketContainer::getHandle, PacketContainer::fromPacket, PacketContainer.class));
 	}
 
 	/**

src/main/java/com/comphenix/protocol/wrappers/Converters.java

@@ -14,25 +14,21 @@
  */
 package com.comphenix.protocol.wrappers;
 
-import java.lang.reflect.Array;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.function.Function;
-import java.util.function.Supplier;
-
 import com.comphenix.protocol.reflect.EquivalentConverter;
 import com.comphenix.protocol.reflect.FuzzyReflection;
 import com.comphenix.protocol.reflect.accessors.Accessors;
 import com.comphenix.protocol.reflect.accessors.MethodAccessor;
 import com.comphenix.protocol.reflect.fuzzy.FuzzyMethodContract;
 import com.comphenix.protocol.utility.MinecraftReflection;
-import org.checkerframework.checker.units.qual.C;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Supplier;
 
 /**
  * Utility class for converters

src/main/java/com/comphenix/protocol/wrappers/EnumWrappers.java

@@ -65,6 +65,7 @@ public abstract class EnumWrappers {
 		/**
 		 * @deprecated Replaced by NOT_SET
 		 */
+		@Deprecated
 		NONE;
 
 		/**
@@ -377,9 +378,9 @@ public abstract class EnumWrappers {
 	
 	/**
 	 * Wrapped EntityPose enum for use in Entity Metadata Packet.<br>
-	 * 
-	 * @apiNote Remember to use {@link #toNms()} when adding to a {@link WrappedDataWatcher}. <br>
-	 *          Serializer is obtained using Registry.get(EnumWrappers.getEntityPoseClass())
+	 * Remember to use {@link #toNms()} when adding to a {@link WrappedDataWatcher}. <br>
+	 * Serializer is obtained using Registry.get(EnumWrappers.getEntityPoseClass())
+	 *
 	 * @since 1.13
 	 * @author Lewys Davies (Lew_)
 	 */

src/main/java/com/comphenix/protocol/wrappers/PlayerInfoData.java

@@ -30,6 +30,8 @@ import com.comphenix.protocol.utility.MinecraftReflection;
 import com.comphenix.protocol.utility.MinecraftVersion;
 import com.comphenix.protocol.wrappers.EnumWrappers.NativeGameMode;
 
+import javax.annotation.Nullable;
+
 /**
  * Represents an immutable PlayerInfoData in the PLAYER_INFO packet.
  * @author dmulloy2
@@ -43,6 +45,9 @@ public class PlayerInfoData {
 	private final NativeGameMode gameMode;
 	private final WrappedGameProfile profile;
 	private final WrappedChatComponent displayName;
+	@Nullable
+	private final WrappedRemoteChatSessionData remoteChatSessionData;
+	@Nullable
 	private final WrappedProfileKeyData profileKeyData;
 
 	// This is the same order as the NMS class, minus the packet (which isn't a field)
@@ -54,7 +59,35 @@ public class PlayerInfoData {
 		this(profile.getUUID(), latency, true, gameMode, profile, displayName, keyData);
 	}
 
-	public PlayerInfoData(UUID profileId, int latency, boolean listed, NativeGameMode gameMode, WrappedGameProfile profile, WrappedChatComponent displayName, WrappedProfileKeyData profileKeyData) {
+	/**
+	 * Constructs a new PlayerInfoData for Minecraft 1.19 or later without signature data
+	 * @see PlayerInfoData#PlayerInfoData(UUID, int, boolean, NativeGameMode, WrappedGameProfile, WrappedChatComponent, WrappedRemoteChatSessionData)
+	 *
+	 * @param profileId the id of the profile (has to be non-null)
+	 * @param latency the latency in milliseconds
+	 * @param listed whether the player is listed in the tab list
+	 * @param gameMode the game mode
+	 * @param profile the game profile
+	 * @param displayName display name in tab list (optional)
+	 */
+	public PlayerInfoData(UUID profileId, int latency, boolean listed, NativeGameMode gameMode, WrappedGameProfile profile, WrappedChatComponent displayName) {
+		this(profileId, latency, listed, gameMode, profile, displayName, (WrappedRemoteChatSessionData) null);
+	}
+
+	/**
+	 * Constructs a new PlayerInfoData for Minecraft 1.19. This is incompatible on 1.19.3.
+	 * @see PlayerInfoData#PlayerInfoData(UUID, int, boolean, NativeGameMode, WrappedGameProfile, WrappedChatComponent, WrappedRemoteChatSessionData)
+	 *
+	 * @param profileId the id of the profile (has to be non-null)
+	 * @param latency the latency in milliseconds
+	 * @param listed whether the player is listed in the tab list
+	 * @param gameMode the game mode
+	 * @param profile the game profile
+	 * @param displayName display name in tab list (optional)
+	 * @param profileKeyData the public key for the profile or null
+	 */
+	@Deprecated
+	public PlayerInfoData(UUID profileId, int latency, boolean listed, NativeGameMode gameMode, WrappedGameProfile profile, WrappedChatComponent displayName, @Nullable WrappedProfileKeyData profileKeyData) {
 		this.profileId = profileId;
 		this.latency = latency;
 		this.listed = listed;
@@ -62,6 +95,29 @@ public class PlayerInfoData {
 		this.profile = profile;
 		this.displayName = displayName;
 		this.profileKeyData = profileKeyData;
+		this.remoteChatSessionData = null;
+	}
+
+	/**
+	 * Constructs a new PlayerInfoData for Minecraft 1.19.3 or later.
+	 *
+	 * @param profileId the id of the profile (has to be non-null)
+	 * @param latency the latency in milliseconds
+	 * @param listed whether the player is listed in the tab list
+	 * @param gameMode the game mode
+	 * @param profile the game profile
+	 * @param displayName display name in tab list (optional)
+	 * @param remoteChatSession the remote chat session for this profile or null
+	 */
+	public PlayerInfoData(UUID profileId, int latency, boolean listed, NativeGameMode gameMode, WrappedGameProfile profile, WrappedChatComponent displayName, @Nullable WrappedRemoteChatSessionData remoteChatSession) {
+		this.profileId = profileId;
+		this.latency = latency;
+		this.listed = listed;
+		this.gameMode = gameMode;
+		this.profile = profile;
+		this.displayName = displayName;
+		this.profileKeyData = null;
+		this.remoteChatSessionData = remoteChatSession;
 	}
 
 	/**
@@ -69,6 +125,9 @@ public class PlayerInfoData {
 	 * @return the id of the profile
 	 */
 	public UUID getProfileId() {
+		if(profileId == null && profile != null) {
+			return profile.getUUID(); // Ensure forward compatability
+		}
 		return profileId;
 	}
 
@@ -97,7 +156,7 @@ public class PlayerInfoData {
 	}
 
 	/**
-	 * Gets if the player is listed on the client.
+	 * Gets if the player is listed on the client (since 1.19.3)
 	 * @return if the player is listed
 	 */
 	public boolean isListed() {
@@ -121,11 +180,21 @@ public class PlayerInfoData {
 	}
 
 	/**
-	 * Gets the profile key data of the player represented by this data, null if not present.
-	 * @return The profile key data
+	 * Returns the public key of the profile (since 1.19). Returns the public key of the remote chat session since 1.19.3
+	 * @return The public key of the profile.
 	 */
+	@Nullable
 	public WrappedProfileKeyData getProfileKeyData() {
-		return this.profileKeyData;
+		return this.profileKeyData != null ? this.profileKeyData : (this.remoteChatSessionData != null ? this.remoteChatSessionData.getProfilePublicKey() : null);
+	}
+
+	/**
+	 * Returns the remoteChatSessionData (since 1.19.3)
+ 	 * @return The remote chat sesion data or null
+	 */
+	@Nullable
+	public WrappedRemoteChatSessionData getRemoteChatSessionData() {
+		return this.remoteChatSessionData;
 	}
 
 	/**
@@ -157,8 +226,7 @@ public class PlayerInfoData {
 						args.add(MinecraftReflection.getIChatBaseComponentClass());
 
 						if (MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
-							// RemoteChatSession$a...
-							args.add(MinecraftReflection.getRemoteChatSessionClass().getClasses()[0]);
+							args.add(MinecraftReflection.getRemoteChatSessionDataClass());
 						} else if (MinecraftVersion.WILD_UPDATE.atOrAbove()) {
 							args.add(MinecraftReflection.getProfilePublicKeyDataClass());
 						}
@@ -175,26 +243,28 @@ public class PlayerInfoData {
 					Object gameMode = EnumWrappers.getGameModeConverter().getGeneric(specific.gameMode);
 					Object displayName = specific.displayName != null ? specific.displayName.handle : null;
 
+					Object profile = specific.profile != null ? specific.profile.handle : null;
 					if (MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
 						return constructor.newInstance(
 								specific.profileId,
-								specific.profile.handle,
+								profile,
 								specific.listed,
 								specific.latency,
 								gameMode,
 								displayName,
-								 null); // TODO: do we want to support this?
+								specific.remoteChatSessionData != null ? BukkitConverters.getWrappedRemoteChatSessionDataConverter().getGeneric(specific.remoteChatSessionData) : null
+						);
 					} else if (MinecraftVersion.WILD_UPDATE.atOrAbove()) {
 						return constructor.newInstance(
-								specific.profile.handle,
+								profile,
 								specific.latency,
 								gameMode,
 								displayName,
 								specific.profileKeyData == null ? null : specific.profileKeyData.handle);
 					} else if (MinecraftVersion.CAVES_CLIFFS_1.atOrAbove()) {
-						return constructor.newInstance(specific.profile.handle, specific.latency, gameMode, displayName);
+						return constructor.newInstance(profile, specific.latency, gameMode, displayName);
 					} else {
-						return constructor.newInstance(null, specific.profile.handle, specific.latency, gameMode, displayName);
+						return constructor.newInstance(null, profile, specific.latency, gameMode, displayName);
 					}
 				} catch (Exception e) {
 					throw new RuntimeException("Failed to construct PlayerInfoData.", e);
@@ -222,8 +292,18 @@ public class PlayerInfoData {
 							MinecraftReflection.getIChatBaseComponentClass(), BukkitConverters.getWrappedChatComponentConverter());
 					WrappedChatComponent displayName = displayNames.read(0);
 
+					if(MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
+						return new PlayerInfoData(modifier.<UUID>withType(UUID.class).read(0),
+								latency,
+								modifier.<Boolean>withType(boolean.class).read(0),
+								gameMode,
+								gameProfile,
+								displayName,
+								modifier.withType(MinecraftReflection.getRemoteChatSessionDataClass(), BukkitConverters.getWrappedRemoteChatSessionDataConverter()).read(0)
+								);
+					}
 					WrappedProfileKeyData key = null;
-					if (MinecraftVersion.WILD_UPDATE.atOrAbove() && !MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
+					if (MinecraftVersion.WILD_UPDATE.atOrAbove()) {
 						StructureModifier<WrappedProfileKeyData> keyData = modifier.withType(
 								MinecraftReflection.getProfilePublicKeyDataClass(), BukkitConverters.getWrappedPublicKeyDataConverter());
 						key = keyData.read(0);
@@ -253,20 +333,34 @@ public class PlayerInfoData {
 		// Only compare objects of similar type
 		if (obj instanceof PlayerInfoData) {
 			PlayerInfoData other = (PlayerInfoData) obj;
-			return profile.equals(other.profile) && latency == other.latency && gameMode == other.gameMode
-					&& Objects.equals(displayName, other.displayName);
+			return Objects.equals(profile, other.profile)
+					&& Objects.equals(profileId, other.profileId)
+					&& latency == other.latency
+					&& gameMode == other.gameMode
+					&& Objects.equals(displayName, other.displayName)
+					&& listed == other.listed
+					&& Objects.equals(remoteChatSessionData, other.remoteChatSessionData)
+					&& Objects.equals(profileKeyData, other.profileKeyData);
 		}
 		return false;
 	}
 
 	@Override
 	public int hashCode() {
-		return Objects.hash(latency, gameMode, profile, displayName);
+		return Objects.hash(latency, gameMode, profile, displayName, profileKeyData, remoteChatSessionData, listed);
 	}
 
 	@Override
 	public String toString() {
+		if(MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
+			return String.format("PlayerInfoData[latency=%s, listed=%b, gameMode=%s, profile=%s, displayName=%s, remoteChatSession=%s]",
+					latency, listed, gameMode, profile, displayName, remoteChatSessionData);
+		}
+		if(MinecraftVersion.WILD_UPDATE.atOrAbove()) {
+			return String.format("PlayerInfoData[latency=%s, listed=%b, gameMode=%s, profile=%s, displayName=%s, profilePublicKey=%s]",
+					latency, listed, gameMode, profile, displayName, profileKeyData);
+		}
 		return String.format("PlayerInfoData[latency=%s, gameMode=%s, profile=%s, displayName=%s]",
-				latency, gameMode, profile, displayName);
+			latency, gameMode, profile, displayName);
 	}
 }

src/main/java/com/comphenix/protocol/wrappers/WrappedAttribute.java

@@ -168,6 +168,7 @@ public class WrappedAttribute extends AbstractWrapper {
 	 * @deprecated Removed in 1.17
 	 */
 	@Nullable
+	@Deprecated
 	public PacketContainer getParentPacket() {
 		if (MinecraftVersion.CAVES_CLIFFS_1.atOrAbove()) {
 			return null;

src/main/java/com/comphenix/protocol/wrappers/WrappedDataWatcher.java

@@ -941,8 +941,8 @@ public class WrappedDataWatcher extends AbstractWrapper implements Iterable<Wrap
 
 		/**
 		 * Gets the first serializer associated with a given class and optional state.
-		 * 
-		 * <p><b>Note</b>: If the serializer is optional, values <i>must<i> be
+		 * <br/>
+		 * <b>Note</b>: If the serializer is optional, values <i>must</i> be
 		 * wrapped in an {@link Optional}
 		 *
 		 * @param clazz Class to find serializer for

src/main/java/com/comphenix/protocol/wrappers/WrappedIntHashMap.java

@@ -16,6 +16,7 @@ import com.google.common.base.Preconditions;
  * @author Kristian
  * @deprecated IntHashMap no longer exists
  */
+@Deprecated
 public class WrappedIntHashMap extends AbstractWrapper {
 	private static Method PUT_METHOD;
 	private static Method GET_METHOD;

src/main/java/com/comphenix/protocol/wrappers/WrappedMessageSignature.java

@@ -0,0 +1,48 @@
+package com.comphenix.protocol.wrappers;
+
+import com.comphenix.protocol.reflect.StructureModifier;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+/**
+ * @author Lukas Alt
+ * @since 24.04.2023
+ */
+public class WrappedMessageSignature extends AbstractWrapper {
+    private final static Class<?> HANDLE_TYPE = MinecraftReflection.getMessageSignatureClass();
+    private static ConstructorAccessor CONSTRUCTOR;
+    private StructureModifier<Object> modifier;
+
+    /**
+     * Construct a new NMS wrapper.
+     *
+     * @param handle - the NMS handle
+     */
+    public WrappedMessageSignature(Object handle) {
+        super(HANDLE_TYPE);
+        this.setHandle(handle);
+    }
+
+    public WrappedMessageSignature(byte[] bytes) {
+        super(HANDLE_TYPE);
+        if(CONSTRUCTOR == null) {
+            CONSTRUCTOR = Accessors.getConstructorAccessor(HANDLE_TYPE, byte[].class);
+        }
+        this.setHandle(CONSTRUCTOR.invoke(bytes));
+    }
+
+    @Override
+    protected void setHandle(Object handle) {
+        super.setHandle(handle);
+        this.modifier = new StructureModifier<>(HANDLE_TYPE).withTarget(handle);
+    }
+
+    public byte[] getBytes() {
+        return modifier.<byte[]>withType(byte[].class).read(0);
+    }
+
+    public void setBytes(byte[] bytes) {
+        modifier.<byte[]>withType(byte[].class).write(0, bytes);
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/WrappedRegistrable.java

@@ -0,0 +1,185 @@
+/**
+ * ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ * Copyright (C) 2015 dmulloy2
+ * <p>
+ * This program is free software; you can redistribute it and/or modify it under the terms of the
+ * GNU General Public License as published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ * <p>
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ * <p>
+ * You should have received a copy of the GNU General Public License along with this program;
+ * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ * 02111-1307 USA
+ */
+package com.comphenix.protocol.wrappers;
+
+import com.comphenix.protocol.reflect.FuzzyReflection;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.FieldAccessor;
+import com.comphenix.protocol.reflect.fuzzy.FuzzyFieldContract;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Represents a wrapper around registrable objects.
+ *
+ * @author portlek
+ */
+public final class WrappedRegistrable extends AbstractWrapper implements ClonableWrapper {
+
+    @NotNull
+    private final Factory factory;
+
+    private WrappedRegistrable(
+        @NotNull final Factory factory,
+        @NotNull final Object handle
+    ) {
+        super(factory.registrableClass);
+        this.factory = factory;
+        setHandle(handle);
+    }
+
+    @NotNull
+    public static WrappedRegistrable fromHandle(
+        @NotNull final Factory factory,
+        @NotNull final Object handle
+    ) {
+        return new WrappedRegistrable(factory, handle);
+    }
+
+    @NotNull
+    public static WrappedRegistrable fromHandle(
+        @NotNull final Class<?> registrableClass,
+        @NotNull final Object handle
+    ) {
+        return fromHandle(Factory.getOrCreate(registrableClass), handle);
+    }
+
+    @NotNull
+    public static WrappedRegistrable fromClassAndKey(
+        @NotNull final Class<?> registrableClass,
+        @NotNull final MinecraftKey key
+    ) {
+        final Factory factory = Factory.getOrCreate(registrableClass);
+        return fromHandle(factory, factory.getHandle(key));
+    }
+
+    @NotNull
+    public static WrappedRegistrable fromClassAndKey(
+        @NotNull final Class<?> registrableClass,
+        @NotNull final String key
+    ) {
+        return fromClassAndKey(registrableClass, new MinecraftKey(key));
+    }
+
+    @NotNull
+    public static WrappedRegistrable blockEntityType(
+        @NotNull final MinecraftKey key
+    ) {
+        return fromClassAndKey(MinecraftReflection.getBlockEntityTypeClass(), key);
+    }
+
+    @NotNull
+    public static WrappedRegistrable blockEntityType(
+        @NotNull final String key
+    ) {
+        return blockEntityType(new MinecraftKey(key));
+    }
+
+    /**
+     * Gets this registrable object's Minecraft key
+     *
+     * @return The Minecraft key
+     */
+    public MinecraftKey getKey() {
+        return factory.getKey(handle);
+    }
+
+    /**
+     * Sets this registrable object's Minecraft key
+     *
+     * @param key Minecraft key
+     */
+    public void setKey(MinecraftKey key) {
+        setHandle(factory.getHandle(key));
+    }
+
+    public WrappedRegistrable deepClone() {
+        return fromHandle(factory, handle);
+    }
+
+    @Override
+    public String toString() {
+        return "WrappedRegistrable[handle=" + handle + "]";
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + getKey().hashCode();
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof WrappedRegistrable)) {
+            return false;
+        }
+        final WrappedRegistrable that = (WrappedRegistrable) o;
+        return handle.equals(that.handle) || (getKey() == that.getKey());
+    }
+
+    private static final class Factory {
+
+        private static final Map<Class<?>, Factory> CACHE = new ConcurrentHashMap<>();
+
+        @NotNull
+        private final Class<?> registrableClass;
+
+        @NotNull
+        private final WrappedRegistry registry;
+
+        @NotNull
+        private final FieldAccessor fieldAccessor;
+
+        private Factory(@NotNull final Class<?> registrableClass) {
+            this.registrableClass = registrableClass;
+            this.registry = WrappedRegistry.getRegistry(registrableClass);
+            this.fieldAccessor = Accessors.getFieldAccessor(
+                FuzzyReflection.fromClass(registrableClass, true)
+                    .getField(
+                        FuzzyFieldContract.newBuilder()
+                            .typeExact(registrableClass)
+                            .build()
+                    )
+            );
+        }
+
+        @NotNull
+        public static Factory getOrCreate(
+            @NotNull final Class<?> registrableClass
+        ) {
+            return CACHE.computeIfAbsent(registrableClass, Factory::new);
+        }
+
+        @NotNull
+        public MinecraftKey getKey(@NotNull final Object handle) {
+            return registry.getKey(fieldAccessor.get(handle));
+        }
+
+        @NotNull
+        public Object getHandle(MinecraftKey key) {
+            return registry.get(key);
+        }
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/WrappedRemoteChatSessionData.java

@@ -0,0 +1,96 @@
+package com.comphenix.protocol.wrappers;
+
+import com.comphenix.protocol.reflect.StructureModifier;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+import java.util.UUID;
+
+/**
+ * A wrapper around the remote chat session.
+ *
+ * @since 1.19.3
+ */
+public class WrappedRemoteChatSessionData extends AbstractWrapper {
+	private final static Class<?> HANDLE_TYPE = MinecraftReflection.getRemoteChatSessionDataClass();
+	private static ConstructorAccessor CONSTRUCTOR;
+	private StructureModifier<Object> modifier;
+
+	/**
+	 * Constructs a new profile public key wrapper directly from a nms RemoteChatSession.Data/RemoteChatSession.a object.
+	 *
+	 * @param handle the handle to create the wrapper from.
+	 */
+	public WrappedRemoteChatSessionData(Object handle) {
+		super(HANDLE_TYPE);
+		this.setHandle(handle);
+	}
+
+	public WrappedRemoteChatSessionData(UUID sessionId, WrappedProfilePublicKey.WrappedProfileKeyData profilePublicKey) {
+		super(HANDLE_TYPE);
+		if (CONSTRUCTOR == null) {
+			CONSTRUCTOR = Accessors.getConstructorAccessor(
+					this.getHandleType(),
+					UUID.class, MinecraftReflection.getProfilePublicKeyDataClass());
+		}
+
+		this.setHandle(CONSTRUCTOR.invoke(sessionId, profilePublicKey.getHandle()));
+	}
+
+	/**
+	 * Retrieves the id of the current session
+	 * @return session id
+	 */
+	public UUID getSessionID() {
+		return this.modifier.<UUID>withType(UUID.class).read(0);
+	}
+
+	/**
+	 * Set the id for this session
+	 * @param sessionId new session id
+	 */
+	public void setSessionID(UUID sessionId) {
+		this.modifier.<UUID>withType(UUID.class).write(0, sessionId);
+	}
+
+	/**
+	 * Retrieves the ProfileKeyData
+	 * @return the public key data for this session
+	 */
+	public WrappedProfilePublicKey.WrappedProfileKeyData getProfilePublicKey() {
+		return this.modifier.withType(MinecraftReflection.getProfilePublicKeyDataClass(), BukkitConverters.getWrappedPublicKeyDataConverter()).read(0);
+	}
+
+	/**
+	 * Set the profile key data for this session
+	 * @param data ProfileKeyData
+	 */
+	public void setProfilePublicKey(WrappedProfilePublicKey.WrappedProfileKeyData data) {
+		this.modifier.withType(MinecraftReflection.getProfilePublicKeyDataClass(), BukkitConverters.getWrappedPublicKeyDataConverter()).write(0, data);
+	}
+
+	@Override
+	protected void setHandle(Object handle) {
+		super.setHandle(handle);
+		this.modifier = new StructureModifier<>(HANDLE_TYPE).withTarget(handle);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if(obj instanceof WrappedRemoteChatSessionData) {
+			return handle.equals(((WrappedRemoteChatSessionData) obj).getHandle());
+		}
+		return false;
+	}
+
+	@Override
+	public String toString() {
+		return handle.toString();
+	}
+
+	@Override
+	public int hashCode() {
+		return handle.hashCode();
+	}
+}

src/main/java/com/comphenix/protocol/wrappers/WrappedServerPing.java

@@ -1,11 +1,8 @@
 package com.comphenix.protocol.wrappers;
 
-import com.comphenix.protocol.PacketType;
 import com.comphenix.protocol.injector.BukkitUnwrapper;
-import com.comphenix.protocol.reflect.EquivalentConverter;
 import com.comphenix.protocol.reflect.accessors.Accessors;
 import com.comphenix.protocol.reflect.accessors.FieldAccessor;
-import com.comphenix.protocol.reflect.accessors.MethodAccessor;
 import com.comphenix.protocol.utility.MinecraftReflection;
 import com.comphenix.protocol.utility.MinecraftVersion;
 import com.comphenix.protocol.wrappers.ping.LegacyServerPing;
@@ -15,7 +12,6 @@ import com.google.common.base.Preconditions;
 import com.google.common.base.Splitter;
 import com.google.common.collect.ImmutableList;
 import com.google.common.io.ByteStreams;
-
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.base64.Base64;
@@ -103,8 +99,10 @@ public class WrappedServerPing implements ClonableWrapper {
 	 * @return The wrapped server ping.
 	 */
 	public static WrappedServerPing fromJson(String json) {
-		// return fromHandle(GSON_FROM_JSON.invoke(PING_GSON.get(null), json, SERVER_PING));
-		return null;
+		if(MinecraftVersion.FEATURE_PREVIEW_2.atOrAbove()) {
+			return new WrappedServerPing(ServerPingRecord.fromJson(json).getHandle());
+		}
+		return new WrappedServerPing(LegacyServerPing.fromJson(json));
 	}
 
 	/**
@@ -350,8 +348,7 @@ public class WrappedServerPing implements ClonableWrapper {
 	 * @return The JSON representation.
 	 */
 	public String toJson() {
-		return null;
-		// return (String) GSON_TO_JSON.invoke(PING_GSON.get(null), getHandle());
+		return impl.getJson();
 	}
 
 	@Override
@@ -546,4 +543,17 @@ public class WrappedServerPing implements ClonableWrapper {
 			return encoded;
 		}
 	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if(!(obj instanceof WrappedServerPing)) {
+			return false;
+		}
+		return getHandle().equals(((WrappedServerPing) obj).getHandle());
+	}
+
+	@Override
+	public int hashCode() {
+		return getHandle().hashCode();
+	}
 }

src/main/java/com/comphenix/protocol/wrappers/codecs/WrappedCodec.java

@@ -0,0 +1,31 @@
+package com.comphenix.protocol.wrappers.codecs;
+
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.AbstractWrapper;
+
+public class WrappedCodec extends AbstractWrapper {
+    private static final Class<?> HANDLE_TYPE = MinecraftReflection.getCodecClass();
+    private static final Class<?> ENCODER_CLASS = MinecraftReflection.getLibraryClass("com.mojang.serialization.Encoder");
+    private static final Class<?> DECODER_CLASS = MinecraftReflection.getLibraryClass("com.mojang.serialization.Decoder");
+    private static final MethodAccessor ENCODE_START_ACCESSOR = Accessors.getMethodAccessor(ENCODER_CLASS, "encodeStart", MinecraftReflection.getDynamicOpsClass(), Object.class);
+    private static final MethodAccessor PARSE_ACCESSOR = Accessors.getMethodAccessor(DECODER_CLASS, "parse", MinecraftReflection.getDynamicOpsClass(), Object.class);
+
+    private WrappedCodec(Object handle) {
+        super(HANDLE_TYPE);
+        this.setHandle(handle);
+    }
+
+    public static WrappedCodec fromHandle(Object handle) {
+        return new WrappedCodec(handle);
+    }
+
+    public WrappedDataResult encode(Object object, WrappedDynamicOps ops) {
+        return WrappedDataResult.fromHandle(ENCODE_START_ACCESSOR.invoke(handle, ops.getHandle(), object));
+    }
+
+    public WrappedDataResult parse(Object value, WrappedDynamicOps ops) {
+        return WrappedDataResult.fromHandle(PARSE_ACCESSOR.invoke(handle, ops.getHandle(), value));
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/codecs/WrappedDataResult.java

@@ -0,0 +1,50 @@
+package com.comphenix.protocol.wrappers.codecs;
+
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.AbstractWrapper;
+
+import java.util.NoSuchElementException;
+import java.util.Optional;
+import java.util.function.Function;
+
+public class WrappedDataResult extends AbstractWrapper {
+    private final static Class<?> HANDLE_TYPE = MinecraftReflection.getLibraryClass("com.mojang.serialization.DataResult");
+    private final static Class<?> PARTIAL_DATA_RESULT_CLASS = MinecraftReflection.getLibraryClass("com.mojang.serialization.DataResult$PartialResult");
+    private final static MethodAccessor ERROR_ACCESSOR = Accessors.getMethodAccessor(HANDLE_TYPE, "error");
+    private final static MethodAccessor RESULT_ACCESSOR = Accessors.getMethodAccessor(HANDLE_TYPE, "result");
+    private final static MethodAccessor PARTIAL_RESULT_MESSAGE_ACCESSOR = Accessors.getMethodAccessor(PARTIAL_DATA_RESULT_CLASS, "message");
+
+    /**
+     * Construct a new NMS wrapper.
+     **/
+    public WrappedDataResult(Object handle) {
+        super(HANDLE_TYPE);
+        this.setHandle(handle);
+    }
+
+    public static WrappedDataResult fromHandle(Object handle) {
+        return new WrappedDataResult(handle);
+    }
+
+    public Optional<Object> getResult() {
+        return (Optional) RESULT_ACCESSOR.invoke(this.handle);
+    }
+
+    public Optional<String> getErrorMessage() {
+        return (Optional) ERROR_ACCESSOR.invoke(this.handle);
+    }
+
+    public Object getOrThrow(Function<String, Throwable> errorHandler) {
+        Optional<String> err = getErrorMessage();
+        if(err.isPresent()) {
+            return errorHandler.apply((String) PARTIAL_RESULT_MESSAGE_ACCESSOR.invoke(err.get()));
+        }
+        Optional<Object> result = getResult();
+        if(result.isPresent()) {
+            return result.get();
+        }
+        throw new NoSuchElementException();
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/codecs/WrappedDynamicOps.java

@@ -0,0 +1,26 @@
+package com.comphenix.protocol.wrappers.codecs;
+
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.FieldAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.AbstractWrapper;
+
+public class WrappedDynamicOps extends AbstractWrapper {
+    private static final Class<?> HANDLE_TYPE = MinecraftReflection.getDynamicOpsClass();
+    public static final FieldAccessor NBT_ACCESSOR = Accessors.getFieldAccessor(MinecraftReflection.getNbtOpsClass(), MinecraftReflection.getNbtOpsClass(), false);
+    public static final FieldAccessor[] JSON_ACCESSORS = Accessors.getFieldAccessorArray(MinecraftReflection.getJsonOpsClass(), MinecraftReflection.getJsonOpsClass(), false);
+    private WrappedDynamicOps(Object handle) {
+        super(HANDLE_TYPE);
+        this.setHandle(handle);
+    }
+    public static WrappedDynamicOps fromHandle(Object handle) {
+        return new WrappedDynamicOps(handle);
+    }
+    public static WrappedDynamicOps json(boolean compressed) {
+        return fromHandle(JSON_ACCESSORS[compressed ? 1 : 0].get(null));
+    }
+
+    public static WrappedDynamicOps nbt() {
+        return fromHandle(NBT_ACCESSOR);
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/collection/ConvertedMap.java

@@ -136,10 +136,10 @@ public abstract class ConvertedMap<Key, VInner, VOuter> extends AbstractConverte
     /**
      * Returns a string representation of this map.  The string representation
      * consists of a list of key-value mappings in the order returned by the
-     * map's <tt>entrySet</tt> view's iterator, enclosed in braces
-     * (<tt>"{}"</tt>).  Adjacent mappings are separated by the characters
-     * <tt>", "</tt> (comma and space).  Each key-value mapping is rendered as
-     * the key followed by an equals sign (<tt>"="</tt>) followed by the
+     * map's <code>entrySet</code> view's iterator, enclosed in braces
+     * (<code>"{}"</code>).  Adjacent mappings are separated by the characters
+     * <code>", "</code> (comma and space).  Each key-value mapping is rendered as
+     * the key followed by an equals sign (<code>"="</code>) followed by the
      * associated value.  Keys and values are converted to strings as by
      * {@link String#valueOf(Object)}.
      *

src/main/java/com/comphenix/protocol/wrappers/collection/ConvertedMultimap.java

@@ -204,10 +204,10 @@ public abstract class ConvertedMultimap<Key, VInner, VOuter> extends AbstractCon
     /**
      * Returns a string representation of this map.  The string representation
      * consists of a list of key-value mappings in the order returned by the
-     * map's <tt>entrySet</tt> view's iterator, enclosed in braces
-     * (<tt>"{}"</tt>).  Adjacent mappings are separated by the characters
-     * <tt>", "</tt> (comma and space).  Each key-value mapping is rendered as
-     * the key followed by an equals sign (<tt>"="</tt>) followed by the
+     * map's <code>entrySet</code> view's iterator, enclosed in braces
+     * (<code>"{}"</code>).  Adjacent mappings are separated by the characters
+     * <code>", "</code> (comma and space).  Each key-value mapping is rendered as
+     * the key followed by an equals sign (<code>"="</code>) followed by the
      * associated value.  Keys and values are converted to strings as by
      * {@link String#valueOf(Object)}.
      *

src/main/java/com/comphenix/protocol/wrappers/ping/LegacyServerPing.java

@@ -286,6 +286,11 @@ public final class LegacyServerPing extends AbstractWrapper implements ServerPin
 		}
 	}
 
+	@Override
+	public String getJson() {
+		return (String) GSON_TO_JSON.invoke(PING_GSON.get(null), getHandle());
+	}
+
 	/**
 	 * Determine if the player count and maximum is visible.
 	 * <p>

src/main/java/com/comphenix/protocol/wrappers/ping/ServerPingImpl.java

@@ -1,10 +1,7 @@
 package com.comphenix.protocol.wrappers.ping;
 
-import java.util.Optional;
-
 import com.comphenix.protocol.wrappers.WrappedChatComponent;
 import com.comphenix.protocol.wrappers.WrappedGameProfile;
-
 import com.google.common.collect.ImmutableList;
 
 public interface ServerPingImpl extends Cloneable {
@@ -38,6 +35,7 @@ public interface ServerPingImpl extends Cloneable {
 
 	boolean arePlayersVisible();
 	void setPlayersVisible(boolean visible);
+	String getJson();
 
 	Object getHandle();
 }

src/main/java/com/comphenix/protocol/wrappers/ping/ServerPingRecord.java

@@ -1,31 +1,39 @@
 package com.comphenix.protocol.wrappers.ping;
 
-import java.nio.charset.StandardCharsets;
-import java.util.List;
-import java.util.Optional;
-import java.util.concurrent.Semaphore;
-
 import com.comphenix.protocol.events.InternalStructure;
 import com.comphenix.protocol.reflect.EquivalentConverter;
 import com.comphenix.protocol.reflect.StructureModifier;
 import com.comphenix.protocol.reflect.accessors.Accessors;
 import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.reflect.accessors.FieldAccessor;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
 import com.comphenix.protocol.utility.MinecraftProtocolVersion;
 import com.comphenix.protocol.utility.MinecraftReflection;
 import com.comphenix.protocol.utility.MinecraftVersion;
 import com.comphenix.protocol.wrappers.*;
-
+import com.comphenix.protocol.wrappers.codecs.WrappedCodec;
+import com.comphenix.protocol.wrappers.codecs.WrappedDynamicOps;
 import com.google.common.collect.ImmutableList;
 import org.bukkit.Bukkit;
 
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+
 public final class ServerPingRecord implements ServerPingImpl {
 	private static Class<?> SERVER_PING;
 	private static Class<?> PLAYER_SAMPLE_CLASS;
 	private static Class<?> SERVER_DATA_CLASS;
 
+	private static Class<?> GSON_CLASS;
+	private static MethodAccessor GSON_TO_JSON;
+	private static MethodAccessor GSON_FROM_JSON;
+	private static FieldAccessor DATA_SERIALIZER_GSON;
+	private static Class<?> JSON_ELEMENT_CLASS;
+
 	private static WrappedChatComponent DEFAULT_DESCRIPTION;
 
 	private static ConstructorAccessor PING_CTOR;
+	private static WrappedCodec CODEC;
 
 	private static EquivalentConverter<List<WrappedGameProfile>> PROFILE_LIST_CONVERTER;
 
@@ -57,6 +65,13 @@ public final class ServerPingRecord implements ServerPingImpl {
 				PROFILE_LIST_CONVERTER = BukkitConverters.getListConverter(BukkitConverters.getWrappedGameProfileConverter());
 
 				DEFAULT_DESCRIPTION = WrappedChatComponent.fromLegacyText("A Minecraft Server");
+
+				GSON_CLASS = MinecraftReflection.getMinecraftGsonClass();
+				GSON_TO_JSON = Accessors.getMethodAccessor(GSON_CLASS, "toJson", Object.class);
+				GSON_FROM_JSON = Accessors.getMethodAccessor(GSON_CLASS, "fromJson", String.class, Class.class);
+				DATA_SERIALIZER_GSON = Accessors.getFieldAccessor(MinecraftReflection.getPacketDataSerializerClass(), GSON_CLASS, true);
+				JSON_ELEMENT_CLASS = MinecraftReflection.getLibraryClass("com.google.gson.JsonElement");
+				CODEC = WrappedCodec.fromHandle(Accessors.getFieldAccessor(SERVER_PING, MinecraftReflection.getCodecClass(), false).get(null));
 			} catch (Exception ex) {
 				throw new RuntimeException("Failed to initialize Server Ping", ex);
 			} finally {
@@ -133,15 +148,26 @@ public final class ServerPingRecord implements ServerPingImpl {
 		int max = Bukkit.getMaxPlayers();
 		int online = Bukkit.getOnlinePlayers().size();
 
-		return new PlayerSample(max, online, null);
+		return new PlayerSample(max, online, new ArrayList<>());
 	}
 
 	private static Favicon defaultFavicon() {
 		return new Favicon();
 	}
 
+	public static ServerPingRecord fromJson(String json) {
+
+		Object jsonElement = GSON_FROM_JSON.invoke(DATA_SERIALIZER_GSON.get(null), json, JSON_ELEMENT_CLASS);
+
+		Object decoded = CODEC.parse(jsonElement, WrappedDynamicOps.json(false)).getOrThrow(e -> new IllegalStateException("Failed to decode: " + e));
+		return new ServerPingRecord(decoded);
+	}
+
 	public ServerPingRecord(Object handle) {
 		initialize();
+		if(handle.getClass() != SERVER_PING) {
+			throw new IllegalArgumentException("Expected handle of type " + SERVER_PING.getName() + " but got " + handle.getClass().getName());
+		}
 
 		StructureModifier<Object> modifier = new StructureModifier<>(handle.getClass()).withTarget(handle);
 		InternalStructure structure = new InternalStructure(handle, modifier);
@@ -286,15 +312,35 @@ public final class ServerPingRecord implements ServerPingImpl {
 		this.playersVisible = visible;
 	}
 
+	@Override
+	public String getJson() {
+		Object encoded = CODEC.encode(getHandle(), WrappedDynamicOps.json(false)).getOrThrow(e -> new IllegalStateException("Failed to encode: " + e));
+		return (String) GSON_TO_JSON.invoke(DATA_SERIALIZER_GSON.get(null), encoded);
+	}
+
 	@Override
 	public Object getHandle() {
 		WrappedChatComponent wrappedDescription = description != null ? description : DEFAULT_DESCRIPTION;
 		Object descHandle = wrappedDescription.getHandle();
 
-		Optional<Object> playersHandle = Optional.ofNullable(playerSample != null ? SAMPLE_WRAPPER.unwrap(playerSample) : null);
+		Optional<Object> playersHandle = Optional.ofNullable(SAMPLE_WRAPPER.unwrap(playerSample != null ? playerSample : new ArrayList<>())); // sample has to be non-null in handle
 		Optional<Object> versionHandle = Optional.ofNullable(serverData != null ? DATA_WRAPPER.unwrap(serverData) : null);
 		Optional<Object> favHandle = Optional.ofNullable(favicon != null ? FAVICON_WRAPPER.unwrap(favicon) : null);
 
 		return PING_CTOR.invoke(descHandle, playersHandle, versionHandle, favHandle, enforceSafeChat);
 	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if(!(obj instanceof ServerPingRecord)) {
+			return false;
+		}
+		ServerPingRecord other = (ServerPingRecord) obj;
+
+		return Objects.equals(description, other.description)
+				&& Objects.equals(playerSample, other.playerSample)
+				&& Objects.equals(serverData, other.serverData)
+				&& ((favicon == null && other.favicon.iconBytes == null)
+				|| ((favicon != null) == (other.favicon != null) && Arrays.equals(favicon.iconBytes, other.favicon.iconBytes)));
+	}
 }

src/main/resources/plugin.yml

@@ -1,5 +1,5 @@
 name: ProtocolLib
-version: ${project.fullVersion}
+version: ${version}
 description: Provides read/write access to the Minecraft protocol.
 authors: [dmulloy2, comphenix]
 

src/test/java/com/comphenix/protocol/BukkitInitialization.java

@@ -41,17 +41,24 @@ public class BukkitInitialization {
 	/**
 	 * Statically initializes the mock server for unit testing
 	 */
-	public static synchronized void initializeAll() {
+	public static void initializeAll() {
 		instance.initialize();
 	}
 
+	private static final Object initLock = new Object();
+
 	/**
-	 * Initialize Bukkit and ProtocolLib such that we can perfrom unit testing
+	 * Initialize Bukkit and ProtocolLib such that we can perform unit testing
 	 */
 	private void initialize() {
-		if (!this.initialized) {
-			// Denote that we're done
-			this.initialized = true;
+		if (initialized) {
+			return;
+		}
+
+		synchronized (initLock) {
+			if (initialized) {
+				return;
+			}
 
 			try {
 				LogManager.getLogger();
@@ -104,6 +111,8 @@ public class BukkitInitialization {
 
 			// Inject this fake server
 			Bukkit.setServer(mockedServer);
+
+			initialized = true;
 		}
 	}
 

src/test/java/com/comphenix/protocol/PacketTypeTest.java

@@ -22,6 +22,7 @@ import com.comphenix.protocol.PacketType.Protocol;
 import com.comphenix.protocol.PacketType.Sender;
 import com.comphenix.protocol.events.PacketContainer;
 import com.comphenix.protocol.injector.packet.PacketRegistry;
+import com.comphenix.protocol.utility.MinecraftReflection;
 import com.comphenix.protocol.utility.MinecraftReflectionTestUtil;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
@@ -31,6 +32,9 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 import java.util.TreeMap;
+
+import com.comphenix.protocol.wrappers.BukkitConverters;
+import com.comphenix.protocol.wrappers.WrappedChatComponent;
 import net.minecraft.network.EnumProtocol;
 import net.minecraft.network.protocol.EnumProtocolDirection;
 import net.minecraft.network.protocol.login.PacketLoginInStart;
@@ -49,9 +53,9 @@ public class PacketTypeTest {
 		BukkitInitialization.initializeAll();
 
 		// I'm well aware this is jank, but it does in fact work correctly and give the desired result
-		PacketType.onDynamicCreate = className -> {
+		/*PacketType.onDynamicCreate = className -> {
 			throw new RuntimeException("Dynamically generated packet " + className);
-		};
+		};*/
 	}
 
 	@AfterAll
@@ -267,11 +271,6 @@ public class PacketTypeTest {
 		return builder.toString();
 	}
 
-	@BeforeAll
-	public static void initializeReflection() {
-		BukkitInitialization.initializeAll();
-	}
-
 	@Test
 	public void testFindCurrent() {
 		assertEquals(PacketType.Play.Client.STEER_VEHICLE,
@@ -297,42 +296,54 @@ public class PacketTypeTest {
 	@Test
 	@SuppressWarnings("unchecked")
 	public void ensureTypesAreCorrect() throws Exception {
-		boolean fail = false;
+		PacketType.onDynamicCreate = className -> {
+			throw new RuntimeException("Dynamically generated packet " + className);
+		};
 
-		EnumProtocol[] protocols = EnumProtocol.values();
-		for (EnumProtocol protocol : protocols) {
-			Field field = EnumProtocol.class.getDeclaredField("k");
-			field.setAccessible(true);
+		try {
+			boolean fail = false;
 
-			Map<EnumProtocolDirection, Object> map = (Map<EnumProtocolDirection, Object>) field.get(protocol);
-			for (Entry<EnumProtocolDirection, Object> entry : map.entrySet()) {
-				Field mapField = entry.getValue().getClass().getDeclaredField("b");
-				mapField.setAccessible(true);
+			EnumProtocol[] protocols = EnumProtocol.values();
+			for (EnumProtocol protocol : protocols) {
+				Field field = EnumProtocol.class.getDeclaredField("k");
+				field.setAccessible(true);
 
-				Map<Class<?>, Integer> reverseMap = (Map<Class<?>, Integer>) mapField.get(entry.getValue());
+				Map<EnumProtocolDirection, Object> map = (Map<EnumProtocolDirection, Object>) field.get(protocol);
+				for (Entry<EnumProtocolDirection, Object> entry : map.entrySet()) {
+					Field mapField = entry.getValue().getClass().getDeclaredField("b");
+					mapField.setAccessible(true);
 
-				Map<Integer, Class<?>> treeMap = new TreeMap<>();
-				for (Entry<Class<?>, Integer> entry1 : reverseMap.entrySet()) {
-					treeMap.put(entry1.getValue(), entry1.getKey());
-				}
+					Map<Class<?>, Integer> reverseMap = (Map<Class<?>, Integer>) mapField.get(entry.getValue());
 
-				for (Entry<Integer, Class<?>> entry1 : treeMap.entrySet()) {
-					try {
-						PacketType type = PacketType.fromClass(entry1.getValue());
-						if (type.getCurrentId() != entry1.getKey()) {
-							throw new IllegalStateException(
-									"Packet ID for " + type + " is incorrect. Expected " + entry1.getKey() + ", but got "
-											+ type.getCurrentId());
+					Map<Integer, Class<?>> treeMap = new TreeMap<>();
+					for (Entry<Class<?>, Integer> entry1 : reverseMap.entrySet()) {
+						treeMap.put(entry1.getValue(), entry1.getKey());
+					}
+
+					for (Entry<Integer, Class<?>> entry1 : treeMap.entrySet()) {
+						try {
+							PacketType type = PacketType.fromClass(entry1.getValue());
+							if (type.getCurrentId() != entry1.getKey()) {
+								throw new IllegalStateException(
+										"Packet ID for " + type + " is incorrect. Expected " + entry1.getKey() + ", but got "
+												+ type.getCurrentId());
+							}
+						} catch (Throwable ex) {
+							if (ex.getMessage().contains("BundleDelimiterPacket")) {
+								continue;
+							}
+
+							ex.printStackTrace();
+							fail = true;
 						}
-					} catch (Throwable ex) {
-						ex.printStackTrace();
-						fail = true;
 					}
 				}
 			}
-		}
 
-		assertFalse(fail, "Packet type(s) were incorrect!");
+			assertFalse(fail, "Packet type(s) were incorrect!");
+		} finally {
+			PacketType.onDynamicCreate = __ -> { };
+		}
 	}
 
 	@Test
@@ -350,4 +361,17 @@ public class PacketTypeTest {
 		}
 		assertFalse(fail, "Packet type(s) failed to instantiate");
 	}
+
+	@Test
+	public void testPacketBundleWriting() {
+		PacketContainer bundlePacket = new PacketContainer(PacketType.Play.Server.BUNDLE);
+		assertEquals(MinecraftReflection.getPackedBundlePacketClass().orElseThrow(() -> new IllegalStateException("Packet Bundle class is not present")), bundlePacket.getHandle().getClass());
+		List<PacketContainer> bundle = new ArrayList<>();
+
+		PacketContainer chatMessage = new PacketContainer(PacketType.Play.Server.SYSTEM_CHAT);
+		chatMessage.getStrings().write(0, WrappedChatComponent.fromText("Test").getJson());
+		chatMessage.getBooleans().write(0, false);
+		bundle.add(chatMessage);
+		bundlePacket.getPacketBundles().write(0, bundle);
+	}
 }

src/test/java/com/comphenix/protocol/events/PacketContainerTest.java

@@ -40,26 +40,13 @@ import com.comphenix.protocol.reflect.accessors.FieldAccessor;
 import com.comphenix.protocol.reflect.cloning.SerializableCloner;
 import com.comphenix.protocol.utility.MinecraftMethods;
 import com.comphenix.protocol.utility.MinecraftReflection;
-import com.comphenix.protocol.wrappers.BlockPosition;
-import com.comphenix.protocol.wrappers.BukkitConverters;
-import com.comphenix.protocol.wrappers.ComponentConverter;
-import com.comphenix.protocol.wrappers.EnumWrappers;
+import com.comphenix.protocol.wrappers.*;
 import com.comphenix.protocol.wrappers.EnumWrappers.Direction;
 import com.comphenix.protocol.wrappers.EnumWrappers.EntityUseAction;
 import com.comphenix.protocol.wrappers.EnumWrappers.Hand;
 import com.comphenix.protocol.wrappers.EnumWrappers.NativeGameMode;
 import com.comphenix.protocol.wrappers.EnumWrappers.SoundCategory;
-import com.comphenix.protocol.wrappers.MovingObjectPositionBlock;
-import com.comphenix.protocol.wrappers.Pair;
-import com.comphenix.protocol.wrappers.PlayerInfoData;
-import com.comphenix.protocol.wrappers.WrappedBlockData;
-import com.comphenix.protocol.wrappers.WrappedChatComponent;
-import com.comphenix.protocol.wrappers.WrappedDataValue;
-import com.comphenix.protocol.wrappers.WrappedDataWatcher;
 import com.comphenix.protocol.wrappers.WrappedDataWatcher.Registry;
-import com.comphenix.protocol.wrappers.WrappedEnumEntityUseAction;
-import com.comphenix.protocol.wrappers.WrappedGameProfile;
-import com.comphenix.protocol.wrappers.WrappedRegistry;
 import com.comphenix.protocol.wrappers.nbt.NbtCompound;
 import com.comphenix.protocol.wrappers.nbt.NbtFactory;
 import com.google.common.collect.Lists;
@@ -768,7 +755,7 @@ public class PacketContainerTest {
 				NativeGameMode.CREATIVE,
 				new WrappedGameProfile(new UUID(0, 0), "system"),
 				null,
-				null);
+				(WrappedRemoteChatSessionData) null);
 		updatePlayerInfoActions.getPlayerInfoDataLists().write(1, Collections.singletonList(data));
 
 		Set<EnumWrappers.PlayerInfoAction> readActions = updatePlayerInfoActions.getPlayerInfoActions().read(0);
@@ -787,21 +774,17 @@ public class PacketContainerTest {
 		Assertions.assertEquals(NativeGameMode.CREATIVE, firstData.getGameMode());
 	}
 
-	// TODO: fix this this at some point
-	/*
 	@Test
 	public void testSignedChatMessage() {
 		PacketContainer chatPacket = new PacketContainer(PacketType.Play.Client.CHAT);
 
-		byte[] signature = new byte[512];
-		long salt = 124L;
-		WrappedSaltedSignature wrappedSignature = new WrappedSaltedSignature(salt, signature);
-		chatPacket.getSignatures().write(0, wrappedSignature);
+		byte[] signature = new byte[256];
+		WrappedMessageSignature wrappedSignature = new WrappedMessageSignature(signature);
+		chatPacket.getMessageSignatures().write(0, wrappedSignature);
 
-		WrappedSaltedSignature read = chatPacket.getSignatures().read(0);
-		assertEquals(salt, read.getSalt());
-		assertArrayEquals(signature, read.getSignature());
-	}*/
+		WrappedMessageSignature read = chatPacket.getMessageSignatures().read(0);
+		assertArrayEquals(signature, read.getBytes());
+	}
 
 	private void assertPacketsEqualAndSerializable(PacketContainer constructed, PacketContainer cloned) {
 		StructureModifier<Object> firstMod = constructed.getModifier(), secondMod = cloned.getModifier();
@@ -871,7 +854,6 @@ public class PacketContainerTest {
 				}
 
 				// gives some indication which cloning process fails as the checks itself are happening outside this method
-				System.out.println("Cloning " + type);
 
 				// Clone the packet all three ways
 				PacketContainer shallowCloned = constructed.shallowClone();
@@ -886,8 +868,8 @@ public class PacketContainerTest {
 					serializedCloned.getLongs().write(0, 0L);
 				}
 				this.assertPacketsEqualAndSerializable(constructed, serializedCloned);
-			} catch (Exception ex) {
-				Assertions.fail("Unable to clone " + type, ex);
+			} catch (Throwable t) {
+				Assertions.fail("Unable to clone " + type, t);
 			}
 		}
 	}

src/test/java/com/comphenix/protocol/utility/TestUtils.java

@@ -7,7 +7,15 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import com.comphenix.protocol.reflect.accessors.Accessors;
 import java.lang.reflect.Field;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.time.Instant;
 import java.util.List;
+import java.util.Random;
+import java.util.UUID;
+
+import com.comphenix.protocol.wrappers.WrappedProfilePublicKey;
+import com.comphenix.protocol.wrappers.WrappedRemoteChatSessionData;
 import org.bukkit.Bukkit;
 import org.bukkit.inventory.ItemStack;
 
@@ -49,4 +57,17 @@ public class TestUtils {
 	public static void setFinalField(Object obj, Field field, Object newValue) {
 		Accessors.getFieldAccessor(field).set(obj, newValue);
 	}
+
+	public static KeyPair generateKeyPair() throws Exception {
+		KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+		keyPairGenerator.initialize(1024);
+		return keyPairGenerator.generateKeyPair();
+	}
+
+	public static WrappedRemoteChatSessionData creteDummyRemoteChatSessionData() throws Exception {
+		byte[] signature = new byte[256];
+		new Random().nextBytes(signature);
+
+		return new WrappedRemoteChatSessionData(UUID.randomUUID(), new WrappedProfilePublicKey.WrappedProfileKeyData(Instant.now(), TestUtils.generateKeyPair().getPublic(), signature));
+	}
 }

src/test/java/com/comphenix/protocol/wrappers/BukkitConvertersTest.java

@@ -1,15 +1,11 @@
 package com.comphenix.protocol.wrappers;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 import com.comphenix.protocol.BukkitInitialization;
 import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.ProtocolLibrary;
 import com.comphenix.protocol.events.PacketContainer;
 import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.utility.TestUtils;
 import com.comphenix.protocol.wrappers.Either.Left;
-
 import org.apache.commons.lang.builder.EqualsBuilder;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
@@ -20,37 +16,41 @@ import org.bukkit.inventory.meta.ItemMeta;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.*;
+
 public class BukkitConvertersTest {
 
-	@BeforeAll
-	public static void beforeClass() {
-		BukkitInitialization.initializeAll();
-	}
+    @BeforeAll
+    public static void beforeClass() {
+        BukkitInitialization.initializeAll();
+    }
 
-	@Test
-	public void testItemStacks() {
-		ItemStack item = new ItemStack(Material.DIAMOND_SWORD, 16);
-		item.addEnchantment(Enchantment.DAMAGE_ALL, 4);
-		ItemMeta meta = item.getItemMeta();
-		meta.setDisplayName(ChatColor.GREEN + "Diamond Sword");
-		item.setItemMeta(meta);
+    @Test
+    public void testItemStacks() {
+        ItemStack item = new ItemStack(Material.DIAMOND_SWORD, 16);
+        item.addEnchantment(Enchantment.DAMAGE_ALL, 4);
+        ItemMeta meta = item.getItemMeta();
+        meta.setDisplayName(ChatColor.GREEN + "Diamond Sword");
+        item.setItemMeta(meta);
 
-		EquivalentConverter<ItemStack> converter = BukkitConverters.getItemStackConverter();
-		Object nmsStack = converter.getGeneric(item);
-		ItemStack back = converter.getSpecific(nmsStack);
+        EquivalentConverter<ItemStack> converter = BukkitConverters.getItemStackConverter();
+        Object nmsStack = converter.getGeneric(item);
+        ItemStack back = converter.getSpecific(nmsStack);
 
-		assertEquals(item.getType(), back.getType());
-		assertEquals(item.getDurability(), back.getDurability());
-		assertEquals(item.hasItemMeta(), back.hasItemMeta());
-		assertTrue(Bukkit.getItemFactory().equals(item.getItemMeta(), back.getItemMeta()));
-	}
+        assertEquals(item.getType(), back.getType());
+        assertEquals(item.getDurability(), back.getDurability());
+        assertEquals(item.hasItemMeta(), back.hasItemMeta());
+        assertTrue(Bukkit.getItemFactory().equals(item.getItemMeta(), back.getItemMeta()));
+    }
 
     @Test
     public void testEither() {
         Either<String, String> test = new Left<>("bla");
 
         EquivalentConverter<Either<String, String>> converter = BukkitConverters.getEitherConverter(
-            Converters.passthrough(String.class), Converters.passthrough(String.class)
+                Converters.passthrough(String.class), Converters.passthrough(String.class)
         );
 
         com.mojang.datafixers.util.Either<String, String> nmsEither = (com.mojang.datafixers.util.Either<String, String>) converter.getGeneric(test);
@@ -72,4 +72,23 @@ public class BukkitConvertersTest {
 			assertTrue(EqualsBuilder.reflectionEquals(container, specific)); // PacketContainer does not properly implement equals(.)
 		}
 	}
+
+	@Test
+	void getWrappedMessageSignatureConverter() {
+		byte[] data = new byte[256];
+		new Random().nextBytes(data);
+		WrappedMessageSignature messageSignature = new WrappedMessageSignature(data);
+
+		assertArrayEquals(data, BukkitConverters.getWrappedMessageSignatureConverter().getSpecific(BukkitConverters.getWrappedMessageSignatureConverter().getGeneric(messageSignature)).getBytes());
+	}
+
+    @Test
+    public void testRemoteChatSessionDataConverter() throws Exception {
+        WrappedRemoteChatSessionData wrappedRemoteChatSessionData = TestUtils.creteDummyRemoteChatSessionData();
+        Object generic = BukkitConverters.getWrappedRemoteChatSessionDataConverter().getGeneric(wrappedRemoteChatSessionData);
+
+		WrappedRemoteChatSessionData specific = BukkitConverters.getWrappedRemoteChatSessionDataConverter().getSpecific(generic);
+		assertEquals(wrappedRemoteChatSessionData, specific);
+
+    }
 }

src/test/java/com/comphenix/protocol/wrappers/PlayerInfoDataTest.java

@@ -17,6 +17,7 @@ package com.comphenix.protocol.wrappers;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import com.comphenix.protocol.BukkitInitialization;
+import com.comphenix.protocol.utility.TestUtils;
 import com.comphenix.protocol.wrappers.EnumWrappers.NativeGameMode;
 import java.util.UUID;
 import org.junit.jupiter.api.BeforeAll;
@@ -33,14 +34,19 @@ public class PlayerInfoDataTest {
 	}
 
 	@Test
-	public void test() {
+	public void test() throws Exception {
 		WrappedGameProfile profile = new WrappedGameProfile(UUID.randomUUID(), "Name");
 		WrappedChatComponent displayName = WrappedChatComponent.fromText("Name's Name");
 
-		PlayerInfoData data = new PlayerInfoData(profile, 42, NativeGameMode.CREATIVE, displayName);
+		testWriteBack(new PlayerInfoData(profile, 42, NativeGameMode.CREATIVE, displayName));
+		testWriteBack(new PlayerInfoData(profile.getUUID(), 42, false, NativeGameMode.CREATIVE, profile, displayName, TestUtils.creteDummyRemoteChatSessionData()));
+		testWriteBack(new PlayerInfoData(profile.getUUID(), 42, false, NativeGameMode.CREATIVE, null, null, TestUtils.creteDummyRemoteChatSessionData()));
+		testWriteBack(new PlayerInfoData(profile.getUUID(), 42, true, NativeGameMode.CREATIVE, null, displayName));
+	}
+
+	private static void testWriteBack(PlayerInfoData data) {
 		Object generic = PlayerInfoData.getConverter().getGeneric(data);
 		PlayerInfoData back = PlayerInfoData.getConverter().getSpecific(generic);
-
 		assertEquals(data, back);
 	}
 }

src/test/java/com/comphenix/protocol/wrappers/WrappedServerPingTest.java

@@ -9,6 +9,7 @@ import com.comphenix.protocol.events.PacketContainer;
 import com.comphenix.protocol.utility.MinecraftProtocolVersion;
 import com.comphenix.protocol.wrappers.WrappedServerPing.CompressedImage;
 import com.google.common.io.Resources;
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder;
@@ -49,6 +50,18 @@ public class WrappedServerPingTest {
 
 		WrappedServerPing roundTrip = packet.getServerPings().read(0);
 
+		String asJson = serverPing.toJson();
+		WrappedServerPing deserialized = WrappedServerPing.fromJson(asJson);
+		deserialized.setMotD(serverPing.getMotD());
+
+		// Deserializing to JSON and parsing the JSON again can lead to a different object as the Mojang Datafixer optimizes server icons or reorders components in the server description
+		assertEquals(serverPing.getVersionName(), deserialized.getVersionName(), "Failed to serialize as JSON and deserialize afterwards (version name mismatch)");
+		assertEquals(serverPing.getVersionProtocol(), deserialized.getVersionProtocol(), "Failed to serialize as JSON and deserialize afterwards (version protocol mismatch)");
+		assertEquals(serverPing.getPlayersOnline(), deserialized.getPlayersOnline(), "Failed to serialize as JSON and deserialize afterwards (players online mismatch)");
+		assertEquals(serverPing.getPlayersMaximum(), deserialized.getPlayersMaximum(), "Failed to serialize as JSON and deserialize afterwards (players maximum mismatch)");
+		assertEquals(serverPing.getPlayers(), deserialized.getPlayers(), "Failed to serialize as JSON and deserialize afterwards (player sample mismatch)");
+		assertEquals(PlainTextComponentSerializer.plainText().serialize(AdventureComponentConverter.fromWrapper(serverPing.getMotD())), PlainTextComponentSerializer.plainText().serialize(AdventureComponentConverter.fromWrapper(deserialized.getMotD()))); // Check if plain text is equivalent
+
 		assertEquals(5, roundTrip.getPlayersOnline());
 		assertEquals(10, roundTrip.getPlayersMaximum());
 		assertEquals("Minecraft 123", roundTrip.getVersionName());