public class SaveableSO : ScriptableObject
    {
        [SerializeField] private string id = Guid.NewGuid().ToString();

        public string ID => id;
    }

public class SaveableSOFormatter : IMessagePackFormatter<SaveableSO>
{
    public void Serialize(ref MessagePackWriter writer, SaveableSO value, MessagePackSerializerOptions options)
    {
        if(value == null)
        {
            writer.WriteNil();
            return;
        }

        writer.Write(value.ID);
    }

    public SaveableSO Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
    {
        if (reader.TryReadNil()) return null;

        options.Security.DepthStep(ref reader);

        string id = reader.ReadString();

        reader.Depth--;
        var handle = Addressables.LoadAssetAsync<SaveableSO>(id);

        return handle.WaitForCompletion();
    }
}

public class SaveableSOResolver : IFormatterResolver
{
    public static readonly IFormatterResolver Instance = new SaveableSOResolver();
    public IMessagePackFormatter<T> GetFormatter<T>()
    {
        return FormatterCache<T>.Formatter;
    }

    private static class FormatterCache<T>
    {
        public static readonly IMessagePackFormatter<T> Formatter;

        // generic's static constructor should be minimized for reduce type generation size!
        // use outer helper method.
        static FormatterCache()
        {
            Formatter = (IMessagePackFormatter<T>)SaveableSOResolverGetFormatterHelper.GetFormatter(typeof(T));
        }
    }
}

internal static class SaveableSOResolverGetFormatterHelper
{
    // If type is concrete type, use type-formatter map
    static readonly Dictionary<Type, object> formatterMap = new Dictionary<Type, object>()
{
    {typeof(SaveableSO), new SaveableSOFormatter()}
    // add more your own custom serializers.
};

    internal static object GetFormatter(Type t)
    {
        object formatter;
        if (formatterMap.TryGetValue(t, out formatter))
        {
            return formatter;
        }

        // If type can not get, must return null for fallback mechanism.
        return null;
    }
}

            var resolver = MessagePack.Resolvers.CompositeResolver.Create(
                MessagePack.Unity.UnityResolver.InstanceWithStandardResolver,
                SaveableSOResolver.Instance);

            options = MessagePackSerializerOptions.Standard.WithResolver(resolver);