feat: libp2p, wasm ios and git lfs for libs

Author: Larkooo

.gitattributes

@@ -1 +1,3 @@
-Assets/WebGLTemplates/TemplateData/* linguist-vendored
+Assets/WebGLTemplates/TemplateData/* linguist-vendored
+*.dll filter=lfs diff=lfs merge=lfs -text
+*.a filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -71,4 +71,10 @@ crashlytics-build.properties
 /[Aa]ssets/[Ss]treamingAssets/aa.meta
 /[Aa]ssets/[Ss]treamingAssets/aa/*
 
-.DS_Store
+.DS_Store
+
+# builds
+dojo-webgl
+dojo-ios
+dojo-macos
+dojo-windows

Assets/Dojo/.DS_Store

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b3a0bf9852c12b00f5da6355e1fb4ea184023cc2a034a985cab0801e580f5a1f
+size 56730668

Assets/Dojo/Libraries/aarch64-apple-darwin/libdojo_c.dylib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea302729331d5f3c3980d97afe2bedba738e7c071b03e51b547c1a19e7237b00
+size 287884432

Assets/Dojo/Libraries/x86_64-apple-darwin/libdojo_c.dylib

@@ -131,11 +131,6 @@ private void HandleEntityUpdate(FieldElement hashedKeys, Model[] entityModels)
         // Register our entity callbacks
         public void RegisterEntityCallbacks()
         {
-#if UNITY_WEBGL && !UNITY_EDITOR
-            worldManager.wasmClient.RegisterEntityStateUpdates(new FieldElement[] { });
-#else
-            worldManager.toriiClient.RegisterEntityStateUpdates(new dojo.FieldElement[] { });
-#endif
             ToriiEvents.Instance.OnEntityUpdated += HandleEntityUpdate;
         }
     }

Assets/Dojo/Libraries/x86_64-unknown-linux-gnu.meta

@@ -6,27 +6,37 @@
 using dojo_bindings;
 using JetBrains.Annotations;
 using Dojo.Starknet;
+using UnityEditor.AppleTV;
 namespace Dojo.Torii
 {
     public unsafe class ToriiClient
     {
-        private dojo.FnPtr_FieldElement_CArrayModel_Void.@delegate entityStateUpdateHandler;
-        private dojo.FnPtr_Void.@delegate syncModelUpdateHandler;
+        private dojo.FnPtr_FieldElement_CArrayModel_Void.@delegate onEntityStateUpdate;
+        private dojo.FnPtr_Void.@delegate onSyncModelUpdate;
+        private dojo.FnPtr_CString_CString_CString_CString_CArrayu8_Void.@delegate onMessage;
         private dojo.ToriiClient* client;
 
-        public ToriiClient(string toriiUrl, string rpcUrl, string world)
+        public ToriiClient(string toriiUrl, string rpcUrl, string relayUrl, string world)
         {
             CString ctoriiUrl = CString.FromString(toriiUrl);
             CString crpcUrl = CString.FromString(rpcUrl);
+            CString crelayUrl = CString.FromString(relayUrl);
             CString cworld = CString.FromString(world);
-            
-            var result = dojo.client_new(ctoriiUrl, crpcUrl, cworld, (dojo.KeysClause*)0, (UIntPtr)0);
+
+            var result = dojo.client_new(ctoriiUrl, crpcUrl, crelayUrl, cworld, (dojo.KeysClause*)0, (UIntPtr)0);
             if (result.tag == dojo.ResultToriiClient_Tag.ErrToriiClient)
             {
                 throw new Exception(result.err.message);
             }
 
             client = result._ok;
+
+            // start event loops & register events
+            StartSubscription();
+            RunLibp2p();
+
+            RegisterEntityStateUpdateEvent(new dojo.FieldElement[] { });
+            RegisterOnMessageEvent();
         }
 
         // We assume the torii client won't be copied around.
@@ -44,25 +54,26 @@ public dojo.WorldMetadata WorldMetadata()
             return worldMetadata;
         }
 
-        [CanBeNull]
-        public Ty Model(dojo.KeysClause query)
-        {
-            dojo.ResultCOptionTy result = dojo.client_model(client, &query);
-            if (result.tag == dojo.ResultCOptionTy_Tag.ErrCOptionTy)
-            {
-                throw new Exception(result.err.message);
-            }
-
-            // can be None - nullable
-            if (result.ok.tag == dojo.COptionTy_Tag.NoneTy)
-            {
-                return null;
-            }
-
-            // we instantiate a new managed Ty object
-            // which will free the underlying c ty when it is garbage collected
-            return new Ty(result.ok._some);
-        }
+        // NOT USED? potentially deprecated
+        // [CanBeNull]
+        // public Model Model(dojo.KeysClause query)
+        // {
+        //     dojo.ResultCOptionTy result = dojo.client_model(client, &query);
+        //     if (result.tag == dojo.ResultCOptionTy_Tag.ErrCOptionTy)
+        //     {
+        //         throw new Exception(result.err.message);
+        //     }
+
+        //     // can be None - nullable
+        //     if (result.ok.tag == dojo.COptionTy_Tag.NoneTy)
+        //     {
+        //         return null;
+        //     }
+
+        //     // we instantiate a new managed Ty object
+        //     // which will free the underlying c ty when it is garbage collected
+        //     return new Ty(result.ok._some.);
+        // }
 
         public List<Entity> Entities(dojo.Query query)
         {
@@ -76,7 +87,7 @@ public List<Entity> Entities(dojo.Query query)
             for (var i = 0; i < (int)result._ok.data_len; i++)
             {
                 entities.Add(new Entity(result._ok.data[i]));
-                // dojo.entity_free(&result._ok.data[i]);
+                dojo.entity_free(&result._ok.data[i]);
             }
 
             dojo.carray_free(result._ok.data, result._ok.data_len);
@@ -132,9 +143,9 @@ public void RemoveModelsToSync(dojo.KeysClause[] models)
             }
         }
 
-        public void RegisterSyncModelUpdates(dojo.KeysClause model, bool dispatchToMainThread = true)
+        public void RegisterSyncModelUpdateEvent(dojo.KeysClause model, bool dispatchToMainThread = true)
         {
-            syncModelUpdateHandler = () =>
+            onSyncModelUpdate = () =>
             {
                 if (dispatchToMainThread)
                 {
@@ -146,14 +157,14 @@ public void RegisterSyncModelUpdates(dojo.KeysClause model, bool dispatchToMainT
                 }
             };
 
-            dojo.Resultbool res = dojo.client_on_sync_model_update(client, model, new dojo.FnPtr_Void(syncModelUpdateHandler));
+            dojo.Resultbool res = dojo.client_on_sync_model_update(client, model, new dojo.FnPtr_Void(onSyncModelUpdate));
             if (res.tag == dojo.Resultbool_Tag.Errbool)
             {
                 throw new Exception(res.err.message);
             }
         }
 
-        public void RegisterEntityStateUpdates(dojo.FieldElement[] entities, bool dispatchToMainThread = true)
+        private void RegisterEntityStateUpdateEvent(dojo.FieldElement[] entities, bool dispatchToMainThread = true)
         {
             dojo.FieldElement* entitiesPtr;
 
@@ -162,17 +173,16 @@ public void RegisterEntityStateUpdates(dojo.FieldElement[] entities, bool dispat
                 entitiesPtr = ptr;
             }
 
-            entityStateUpdateHandler = (key, models) =>
+            onEntityStateUpdate = (key, models) =>
             {
                 var mappedModels = new Model[(int)models.data_len];
                 for (var i = 0; i < (int)models.data_len; i++)
                 {
                     mappedModels[i] = new Model(models.data[i]);
-                    // TODO: free the c model
-                    // dojo.model_free(&models.data[i]);
+                    // cleanup model
+                    dojo.model_free(&models.data[i]);
                 }
 
-                dojo.carray_free(models.data, models.data_len);
                 // only run this when in unity play mode
                 // we need our unity main thread dispatcher to run this on the main thread
                 if (dispatchToMainThread)
@@ -183,36 +193,42 @@ public void RegisterEntityStateUpdates(dojo.FieldElement[] entities, bool dispat
                 {
                     ToriiEvents.Instance.EntityUpdated(new FieldElement(key), mappedModels);
                 }
+
+                // cleanup
+                dojo.carray_free(models.data, models.data_len);
+                // TODO: free field element
             };
 
 
             // dojo.FnPtr_FieldElement_CArrayModel_Void.@delegate callbackHandler = HandleEntityStateUpdate;
-            dojo.Resultbool res = dojo.client_on_entity_state_update(client, entitiesPtr, (nuint)entities.Length, new dojo.FnPtr_FieldElement_CArrayModel_Void(entityStateUpdateHandler));
+            dojo.Resultbool res = dojo.client_on_entity_state_update(client, entitiesPtr, (nuint)entities.Length, new dojo.FnPtr_FieldElement_CArrayModel_Void(onEntityStateUpdate));
             if (res.tag == dojo.Resultbool_Tag.Errbool)
             {
                 throw new Exception(res.err.message);
             }
         }
-
-        public void OnEntityStateUpdateRaw(dojo.FieldElement[] entities, dojo.FnPtr_FieldElement_CArrayModel_Void.@delegate callbackHandler)
+        private void RegisterOnMessageEvent(bool dispatchToMainThread = true)
         {
-            dojo.FieldElement* entitiesPtr;
-
-            fixed (dojo.FieldElement* ptr = entities)
+            onMessage = (CString propagationSource, CString source, CString messageId, CString topic, dojo.CArrayu8 data) =>
             {
-                entitiesPtr = ptr;
-            }
+                if (dispatchToMainThread)
+                {
+                    UnityMainThreadDispatcher.Instance().Enqueue(() => ToriiEvents.Instance.Message(propagationSource.ToString(), source.ToString(), messageId.ToString(), topic.ToString(), new Span<byte>(data.data, (int)data.data_len).ToArray()));
+                }
+                else
+                {
+                    ToriiEvents.Instance.Message(propagationSource.ToString(), source.ToString(), messageId.ToString(), topic.ToString(), new Span<byte>(data.data, (int)data.data_len).ToArray());
+                }
 
-            dojo.Resultbool res = dojo.client_on_entity_state_update(client, entitiesPtr, (nuint)entities.Length, new dojo.FnPtr_FieldElement_CArrayModel_Void(callbackHandler));
-            if (res.tag == dojo.Resultbool_Tag.Errbool)
-            {
-                throw new Exception(res.err.message);
-            }
-        }
+                // cleanup
+                dojo.string_free(propagationSource);
+                dojo.string_free(source);
+                dojo.string_free(messageId);
+                dojo.string_free(topic);
+                dojo.carray_free(data.data, data.data_len);
+            };
 
-        public void OnSyncModelUpdateRaw(dojo.KeysClause model, dojo.FnPtr_Void.@delegate callbackHandler)
-        {
-            dojo.Resultbool res = dojo.client_on_sync_model_update(client, model, new dojo.FnPtr_Void(callbackHandler));
+            dojo.Resultbool res = dojo.client_on_message(client, new dojo.FnPtr_CString_CString_CString_CString_CArrayu8_Void(onMessage));
             if (res.tag == dojo.Resultbool_Tag.Errbool)
             {
                 throw new Exception(res.err.message);
@@ -227,5 +243,11 @@ public void StartSubscription()
                 throw new Exception(result.err.message);
             }
         }
+
+        public void RunLibp2p()
+        {
+            dojo.client_run_libp2p(client);
+        }
+
     }
 }

Assets/Dojo/Libraries.meta renamed to Assets/Dojo/Plugins/Linux.meta

@@ -1,3 +1,4 @@
+using System;
 using Dojo.Starknet;
 using dojo_bindings;
 
@@ -22,9 +23,11 @@ public static ToriiEvents Instance
 
         public delegate void OnSyncModelUpdateDelegate();
         public delegate void OnEntityStateUpdateDelegate(FieldElement key, Model[] models);
+        public delegate void OnMessageDelegate(string propagationSource, string source, string messageId, string topic, Span<byte> data);
 
         public event OnEntityStateUpdateDelegate OnEntityUpdated;
         public event OnSyncModelUpdateDelegate OnSyncModelUpdated;
+        public event OnMessageDelegate OnMessage;
 
         public void EntityUpdated(FieldElement key, Model[] models)
         {
@@ -35,5 +38,10 @@ public void SyncModelUpdated()
         {
             OnSyncModelUpdated?.Invoke();
         }
+
+        public void Message(string propagationSource, string source, string messageId, string topic, Span<byte> data)
+        {
+            OnMessage?.Invoke(propagationSource, source, messageId, topic, data);
+        }
     }
 }

Assets/Dojo/Libraries/x86_64-pc-windows-gnu/libdojo_c.dll renamed to Assets/Dojo/Plugins/Linux/libdojo_c.so

@@ -26,17 +26,13 @@ public ToriiWasmClient(string toriiUrl, string rpcUrl, string world)
         public async Task CreateClient()
         {
             clientPtr = await ToriiWasmInterop.CreateClientAsync(rpcUrl, toriiUrl, world);
+            ToriiWasmInterop.OnEntityUpdated(clientPtr, new FieldElement[] { });
         }
 
         public async Task<List<Entity>> Entities(int limit, int offset)
         {
             var entities = await ToriiWasmInterop.GetEntitiesAsync(clientPtr, limit, offset);
             return entities;
         }
-
-        public void RegisterEntityStateUpdates(FieldElement[] entities)
-        {
-            ToriiWasmInterop.OnEntityUpdated(clientPtr, entities);
-        }
     }
 }