controller call & interop

Author: Larkooo

Assets/Dojo/Runtime/Controller.cs

@@ -29,6 +29,29 @@ public dojo.Policy ToNative()
         }
     }
 
+    [Serializable]
+    public struct ControllerCall {
+        public FieldElement contractAddress;
+        public string entrypoint;
+        public FieldElement[] calldata;
+
+        public ControllerCall(FieldElement contractAddress, string entrypoint, FieldElement[] calldata)
+        {
+            this.contractAddress = contractAddress;
+            this.entrypoint = entrypoint;
+            this.calldata = calldata;
+        }
+
+        public dojo.Call ToNative()
+        {
+            return new dojo.Call {
+                to = contractAddress.Inner,
+                selector = entrypoint,
+                calldata = calldata.Select(c => c.Inner).ToArray()
+            };
+        }
+    }
+
     public unsafe class Controller
     {
         private dojo.ControllerAccount* controller;
@@ -113,10 +136,11 @@ public static bool Clear(Policy[] policies, FieldElement chainId)
             return result.ok;
         }
 
-        public FieldElement ExecuteRaw(dojo.Call[] calls)
+        public FieldElement ExecuteRaw(ControllerCall[] calls)
         {
+            var nativeCalls = calls.Select(c => c.ToNative()).ToArray();
             dojo.Call* callsPtr;
-            fixed (dojo.Call* ptr = &calls[0])
+            fixed (dojo.Call* ptr = &nativeCalls[0])
             {
                 callsPtr = ptr;
             }
@@ -130,10 +154,11 @@ public FieldElement ExecuteRaw(dojo.Call[] calls)
             return new FieldElement(result.ok);
         }
 
-        public FieldElement ExecuteFromOutside(dojo.Call[] calls)
+        public FieldElement ExecuteFromOutside(ControllerCall[] calls)
         {
+            var nativeCalls = calls.Select(c => c.ToNative()).ToArray();
             dojo.Call* callsPtr;
-            fixed (dojo.Call* ptr = &calls[0])
+            fixed (dojo.Call* ptr = &nativeCalls[0])
             {
                 callsPtr = ptr;
             }

Assets/Dojo/Runtime/ControllerInterop.cs

@@ -0,0 +1,120 @@
+#if UNITY_WEBGL && !UNITY_EDITOR
+
+using System;
+using System.Threading.Tasks;
+using System.Runtime.InteropServices;
+using AOT;
+using bottlenoselabs.C2CS.Runtime;
+using Newtonsoft.Json;
+using UnityEngine;
+using System.Linq;
+
+namespace Dojo
+{
+    public static class ControllerInterop
+    {
+        [DllImport("__Internal")]
+        private static extern void NewController(CString rpcUrl, CString chainId, CString policies);
+
+        [DllImport("__Internal")]
+        private static extern void Probe(Action<bool> cb);
+
+        private static class ProbeHelper
+        {
+            public static TaskCompletionSource<bool> Tcs;
+
+            [MonoPInvokeCallback(typeof(Action<bool>))]
+            public static void Callback(bool result)
+            {
+                Tcs.SetResult(result);
+            }
+        }
+
+        public static Task<bool> Probe()
+        {
+            ProbeHelper.Tcs = new TaskCompletionSource<bool>();
+            Probe(ProbeHelper.Callback);
+            return ProbeHelper.Tcs.Task;
+        }
+
+
+        [DllImport("__Internal")]
+        private static extern void Connect(Action<bool> cb);
+
+        private static class ConnectHelper
+        {
+            public static TaskCompletionSource<bool> Tcs;
+
+            [MonoPInvokeCallback(typeof(Action<bool>))]
+            public static void Callback(bool result)
+            {
+                Tcs.SetResult(result);
+            }
+        }
+
+        public static Task<bool> Connect()
+        {
+            ConnectHelper.Tcs = new TaskCompletionSource<bool>();
+            Connect(ConnectHelper.Callback);
+            return ConnectHelper.Tcs.Task;
+        }
+
+
+        [DllImport("__Internal")]
+        private static extern void Disconnect(Action cb);
+
+        private static class DisconnectHelper
+        {
+            public static TaskCompletionSource<bool> Tcs; // Using bool to signal completion
+
+            [MonoPInvokeCallback(typeof(Action))]
+            public static void Callback()
+            {
+                Tcs.SetResult(true); // Signal completion
+            }
+        }
+
+        public static Task Disconnect()
+        {
+            DisconnectHelper.Tcs = new TaskCompletionSource<bool>();
+            Disconnect(DisconnectHelper.Callback);
+            return DisconnectHelper.Tcs.Task;
+        }
+
+
+        [DllImport("__Internal")]
+        private static extern void Execute(Action<string> cb, CString calls);
+
+        private static class ExecuteHelper
+        {
+            public static TaskCompletionSource<string> Tcs;
+
+            [MonoPInvokeCallback(typeof(Action<string>))]
+            public static void Callback(string result)
+            {
+                 // The result is the transaction hash from the JS side
+                Tcs.SetResult(result);
+            }
+        }
+
+
+        // Takes ControllerCall structs, serializes them into the expected JSON format
+        public static Task<string> Execute(ControllerCall[] calls)
+        {
+            ExecuteHelper.Tcs = new TaskCompletionSource<string>();
+             var serializedCalls = calls.Select(call => new SerializedCall(
+                new FieldElement(call.to),
+                call.selector,
+                // Ensure dojo.FieldElement can be converted to Dojo.Starknet.FieldElement if they differ
+                // Assuming direct conversion or access to underlying data works:
+                call.calldata.ToArray().Select(f => new FieldElement(f)).ToArray()
+            )).ToArray();
+
+            var jsonCalls = JsonConvert.SerializeObject(serializedCalls);
+            Execute(ExecuteHelper.Callback, new CString(jsonCalls));
+            return ExecuteHelper.Tcs.Task;
+        }
+    }
+}
+
+#endif // UNITY_WEBGL && !UNITY_EDITOR