The cheapest way to store a pointer to the addressable asset

That is an interesting question! I'm not anything near an expert on addressables, so there might be something more obvious that I'm missing completely, but my first two ideas would be:

---

I.

Since Addressables.LoadAssetAsync<T>("AssetAddress"); uses string you can use them and figure out a way to serialize them in the most compact format. Which one is that?

 using UnityEngine;
 using Encoding = System.Text.Encoding;
 public class LetsCompareEncodedTextByteLength : MonoBehaviour
 {
     [SerializeField] string _text = "Level03/Textures/texture-123_diff";
     void Start ()
     {
         byte[] bytesASCII = Encoding.ASCII.GetBytes(_text);
         Debug.Log($"\"{Encoding.ASCII.GetString(bytesASCII)}\" is {bytesASCII.Length} bytes when encoded as ASCII");
 
         byte[] bytesUTF7 = Encoding.UTF7.GetBytes(_text);
         Debug.Log($"\"{Encoding.UTF7.GetString(bytesUTF7)}\" is {bytesUTF7.Length} bytes when encoded as UTF7");
         
         byte[] bytesUTF8 = Encoding.UTF8.GetBytes(_text);
         Debug.Log($"\"{Encoding.UTF8.GetString(bytesUTF8)}\" is {bytesUTF8.Length} bytes when encoded as UTF8");
 
         byte[] bytesUTF32 = Encoding.UTF32.GetBytes(_text);
         Debug.Log($"\"{Encoding.UTF32.GetString(bytesUTF32)}\" is {bytesUTF32.Length} bytes when encoded as UTF32");
 
         byte[] bytesUnicode = Encoding.Unicode.GetBytes(_text);
         Debug.Log($"\"{Encoding.Unicode.GetString(bytesUnicode)}\" is {bytesUnicode.Length} bytes when encoded as Unicode");
     }
 }

UTF8, for example:

"Level03/Textures/texture-123_diff" is 33 bytes when encoded as UTF8

So you can make a decision to use UTF-8 asset addresses only (no culture-specific characters) + serialize them in this format + purposefully limit their length, from now on. Realistically, this would buy you something like 32 (shorter address is ofc possible but impractical) to 128 bytes per asset ptr (assuming 128 chars is this self-imposed limit).

---

II.

You can generate 32-bit ( int, 4 bytes) or 64-bit ( long, 8 bytes) hashes for all the addressable assets (test for hash collisions ofc). Serialize keys while in editor but serialize hashes (only) for production builds & match the two in some kind of look-up table (Hashmap/Dict, file or database).

The most basic look-up table I can possibly imagine is a text file with all the possible string keys and hash is literally just a line number (an uint offset ptr).

This option would be a bit harder, because of required tooling, but would result in constant size 4 or 8 bytes/pointer cost from that point onward (given that the serialization is not lazy JSON, text etc... :T but byte[]).

---