Feature/primitives Config & Signature

.gitignore

@@ -122,5 +122,4 @@ Assets/SequenceSDK/WaaS/Tests/Resources/
 # Foundry
 
 /testchain/lib
-/testchain/artifacts/*
 

Assets/SequenceSDK/EcosystemWallet/IntegrationTests/ConfigTests.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Numerics;
+using System.Threading.Tasks;
+using Sequence.EcosystemWallet.Primitives;
+using Sequence.Utils;
+
+namespace Sequence.EcosystemWallet.IntegrationTests
+{
+    public class ConfigTests
+    {
+        public Task<string> ConfigNew(Dictionary<string, object> parameters)
+        {
+            var threshold = (string)parameters["threshold"];
+            var checkpoint = (string)parameters["checkpoint"];
+            var content = (string)parameters["content"];
+
+            var checkpointer = parameters.TryGetValue("checkpointer", out var checkpointerValue) && 
+                               checkpointerValue != null ? new Address(checkpointerValue as string) : null;
+
+            var config = new Primitives.Config
+            {
+                threshold = BigInteger.Parse(threshold),
+                checkpoint = BigInteger.Parse(checkpoint),
+                topology = Topology.FromLeaves(Topology.ParseContentToLeafs(content)),
+                checkpointer = checkpointer
+            };
+
+            return Task.FromResult(config.ToJson());
+        }
+
+        public Task<string> ConfigEncode(Dictionary<string, object> parameters)
+        {
+            var input = parameters["input"].ToString();
+            var config = Primitives.Config.FromJson(input);
+            var signature = new RawSignature
+            {
+                checkpointerData = null,
+                configuration = config,
+            };
+
+            var encoded = signature.Encode().ByteArrayToHexStringWithPrefix();
+            return Task.FromResult(encoded);
+        }
+
+        public Task<string> ConfigImageHash(Dictionary<string, object> parameters)
+        {
+            var input = parameters["input"].ToString();
+            var config = Primitives.Config.FromJson(input);
+            var imageHash = config.HashConfiguration().ByteArrayToHexStringWithPrefix();
+            return Task.FromResult(imageHash);
+        }
+    }
+}

Assets/SequenceSDK/EcosystemWallet/IntegrationTests/DevToolsTest.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Sequence.EcosystemWallet.IntegrationTests
+{
+    public class DevToolsTest
+    {
+        public Task<string> DevToolsRandomConfig(Dictionary<string, object> parameters)
+        {
+            var maxDepth = int.Parse(parameters["maxDepth"].ToString());
+            var seed = (string)parameters["seed"];
+            var minThresholdOnNested = int.Parse(parameters["minThresholdOnNested"].ToString());
+            var checkpointer = parameters.TryGetValue("checkpointer", out var checkpointerObj) ? checkpointerObj.ToString() : "no";
+            var skewed = parameters.TryGetValue("skewed", out var skewedObj) ? skewedObj.ToString() : "none";
+
+            var options = new DevTools.RandomOptions
+            {
+                seededRandom = string.IsNullOrEmpty(seed) ? null : DevTools.CreateSeededRandom(seed),
+                checkpointer = checkpointer,
+                minThresholdOnNested = minThresholdOnNested,
+                skewed = skewed
+            };
+
+            return Task.FromResult(DevTools.CreateRandomConfig(maxDepth, options).ToJson());
+        }
+
+        public Task<string> DevToolsRandomSessionTopology(Dictionary<string, object> parameters)
+        {
+            throw new System.NotImplementedException("DevToolsTest.DevToolsRandomSessionTopology");
+        }
+    }
+}

Assets/SequenceSDK/EcosystemWallet/IntegrationTests/Server/Server.cs

@@ -15,10 +15,31 @@ internal class Server
         public static readonly Dictionary<string, Func<Dictionary<string, object>, Task<object>>> Methods =
             new Dictionary<string, Func<Dictionary<string, object>, Task<object>>>
             {
+                // PAYLOAD
                 ["payload_toAbi"] = async (parameters) => await new PayloadTests().PayloadToAbi(parameters),
                 ["payload_toPacked"] = async (parameters) => await new PayloadTests().PayloadToPacked(parameters),
                 ["payload_toJson"] = async (parameters) => await new PayloadTests().PayloadToJson(parameters),
                 ["payload_hashFor"] = async (parameters) => await new PayloadTests().PayloadHashFor(parameters),
+                // CONFIG
+                ["config_new"] = async (parameters) => await new ConfigTests().ConfigNew(parameters),
+                ["config_encode"] = async (parameters) => await new ConfigTests().ConfigEncode(parameters),
+                ["config_imageHash"] = async (parameters) => await new ConfigTests().ConfigImageHash(parameters),
+                // DEV TOOLS
+                ["devTools_randomConfig"] = async (parameters) => await new DevToolsTest().DevToolsRandomConfig(parameters),
+                ["devTools_randomSessionTopology"] = async (parameters) => await new DevToolsTest().DevToolsRandomSessionTopology(parameters),
+                // SIGNATURE
+                ["signature_encode"] = async (parameters) => await new SignatureTests().SignatureEncode(parameters),
+                ["signature_concat"] = async (parameters) => await new SignatureTests().SignatureConcat(parameters),
+                ["signature_decode"] = async (parameters) => await new SignatureTests().SignatureDecode(parameters),
+                // SESSIONS
+                ["session_empty"] = async (parameters) => await new SessionsTest().SessionEmpty(parameters),
+                ["session_encodeTopology"] = async (parameters) => await new SessionsTest().SessionEncodeTopology(parameters),
+                ["session_encodeCallSignatures"] = async (parameters) => await new SessionsTest().SessionEncodeCallSignatures(parameters),
+                ["session_imageHash"] = async (parameters) => await new SessionsTest().SessionImageHash(parameters),
+                ["session_explicit_add"] = async (parameters) => await new SessionsTest().SessionExplicitAdd(parameters),
+                ["session_explicit_remove"] = async (parameters) => await new SessionsTest().SessionExplicitRemove(parameters),
+                ["session_implicit_addBlacklistAddress"] = async (parameters) => await new SessionsTest().SessionImplicitAddBlacklistAddress(parameters),
+                ["session_implicit_removeBlacklistAddress"] = async (parameters) => await new SessionsTest().SessionImplicitRemoveBlacklistAddress(parameters),
             };
 
         public async Task<JsonRpcResponse> HandleSingleRequest(
@@ -33,12 +54,7 @@ public async Task<JsonRpcResponse> HandleSingleRequest(
 
             if (!silent)
             {
-                Debug.Log($"[{DateTime.UtcNow:O}] Processing request: method={method} id={id}");
-            }
-
-            if (debug && !silent)
-            {
-                Debug.Log("Request details: " + JsonConvert.SerializeObject(rpcRequest, Formatting.Indented));
+                Debug.Log($"Processing request: method={method} id={id} payload={JsonConvert.SerializeObject(rpcRequest, Formatting.Indented)}");
             }
 
             if (jsonrpc != "2.0")
@@ -47,7 +63,7 @@ public async Task<JsonRpcResponse> HandleSingleRequest(
                     new JsonRpcErrorResponse(new JsonRpcErrorResponse.Error(-32600, "Invalid JSON-RPC version"), id);
                 if (!silent)
                 {
-                    Debug.LogError($"[{DateTime.UtcNow:O}] Error response: {(debug ? JsonConvert.SerializeObject(error) : error.error.message)}");
+                    Debug.LogError($"Error response: {(debug ? JsonConvert.SerializeObject(error) : error.error.message)}");
                 }
 
                 return error;
@@ -58,21 +74,14 @@ public async Task<JsonRpcResponse> HandleSingleRequest(
                 JsonRpcErrorResponse error = new JsonRpcErrorResponse(new JsonRpcErrorResponse.Error(-32601, $"Method not found: {method}"), id);
                 if (!silent)
                 {
-                    Debug.LogError($"[{DateTime.UtcNow:O}] Error response: {(debug ? JsonConvert.SerializeObject(error) : error.error.message)}");
+                    Debug.LogError($"Error response: {(debug ? JsonConvert.SerializeObject(error) : error.error.message)}");
                 }
                 return error;
             }
 
             try
             {
                 Dictionary<string, object> methodParams;
-
-                if (debug && !silent)
-                {
-                    Debug.Log($"[{DateTime.UtcNow:O}] Raw params: {JsonConvert.SerializeObject(@params)}");
-                }
-
-                // Convert params to JObject for more flexible parsing if needed
                 Newtonsoft.Json.Linq.JObject paramsJObject = null;
                 if (@params is Dictionary<string, object> paramsDict)
                 {
@@ -90,20 +99,11 @@ public async Task<JsonRpcResponse> HandleSingleRequest(
                     Debug.LogWarning("No method params");
                 }
 
-                if (debug && !silent)
-                {
-                    Debug.Log($"[{DateTime.UtcNow:O}] Final methodParams: {JsonConvert.SerializeObject(methodParams)}");
-                }
-
                 var result = await Methods[method](methodParams);
                 JsonRpcSuccessResponse response = new JsonRpcSuccessResponse(result, id);
                 if (!silent)
                 {
-                    Debug.Log($"[{DateTime.UtcNow:O}] Success Response for Method={method} id={id}");
-                    if (debug)
-                    {
-                        Debug.Log("Response details: " + JsonConvert.SerializeObject(response, Formatting.Indented));
-                    }
+                    Debug.Log($"Response details for Method={method}: " + JsonConvert.SerializeObject(response, Formatting.Indented) + $", Params used = {JsonConvert.SerializeObject(methodParams)}");
                 }
                 return response;
             }
@@ -112,7 +112,7 @@ public async Task<JsonRpcResponse> HandleSingleRequest(
                 JsonRpcErrorResponse error = new JsonRpcErrorResponse(new JsonRpcErrorResponse.Error(-32000, $"Unknown error: {ex.Message}"), id);
                 if (!silent)
                 {
-                    Debug.LogError($"[{DateTime.UtcNow:O}] Error response: {(debug ? JsonConvert.SerializeObject(error) : error.error.message)}");
+                    Debug.LogError($"Error response: {(debug ? JsonConvert.SerializeObject(error) : error.error.message)} {ex.StackTrace}");
                 }
                 return error;
             }

Assets/SequenceSDK/EcosystemWallet/IntegrationTests/SessionsTest.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Sequence.EcosystemWallet.Primitives;
+using Sequence.EcosystemWallet.UnitTests;
+using Sequence.Utils;
+
+namespace Sequence.EcosystemWallet.IntegrationTests
+{
+    public class SessionsTest
+    {
+        public Task<string> SessionEmpty(Dictionary<string, object> parameters)
+        {
+            var identitySigner = parameters["identitySigner"].ToString();
+            var topology = SessionsUtils.CreateSessionsTopologyWithSingleIdentity(identitySigner);
+
+            return Task.FromResult(topology.JsonSerialize());
+        }
+
+        public Task<string> SessionEncodeTopology(Dictionary<string, object> parameters)
+        {
+            var topologyJson = parameters["sessionTopology"].ToString();
+            var topology = SessionsTopology.FromJson(topologyJson);
+            var encoded = topology.Encode().ByteArrayToHexStringWithPrefix();
+
+            return Task.FromResult(encoded);
+        }
+
+        public Task<string> SessionEncodeCallSignatures(Dictionary<string, object> parameters)
+        {
+            var sessionTopologyJson = parameters["sessionTopology"].ToString();
+
+            var signatures = JsonConvert.DeserializeObject<object[]>(parameters["callSignatures"]
+                .ToString()).Select(s => SessionCallSignature.FromJson(s.ToString())).ToArray();
+
+            var explicitSigners = JsonConvert.DeserializeObject<string[]>(parameters["explicitSigners"]
+                .ToString()).Select(v => new Address(v)).ToArray();
+
+            var implicitSigners = JsonConvert.DeserializeObject<string[]>(parameters["implicitSigners"]
+                .ToString()).Select(v => new Address(v)).ToArray();
+
+            var sessionsTopology = SessionsTopology.FromJson(sessionTopologyJson);
+            var encodedSignatures = SessionCallSignature.EncodeSignatures(signatures, sessionsTopology, explicitSigners, implicitSigners);
+
+            return Task.FromResult(encodedSignatures.ByteArrayToHexStringWithPrefix());
+        }
+
+        public Task<string> SessionImageHash(Dictionary<string, object> parameters)
+        {
+            var sessionTopologyJson = parameters["sessionTopology"].ToString();
+            var topology = SessionsTopology.FromJson(sessionTopologyJson);
+
+            return Task.FromResult(topology.ImageHash());
+        }
+
+        public Task<string> SessionExplicitAdd(Dictionary<string, object> parameters)
+        {
+            var explicitSessionJson = parameters["explicitSession"].ToString();
+            var sessionTopologyJson = parameters["sessionTopology"].ToString();
+
+            var explicitSession = SessionPermissions.FromJson(explicitSessionJson);
+            var sessionTopology = SessionsTopology.FromJson(sessionTopologyJson);
+
+            var existingPermission = sessionTopology.FindLeaf<PermissionLeaf>(leaf => 
+                leaf.permissions.signer.Equals(explicitSession.signer));
+
+            if (existingPermission != null)
+                throw new Exception("Session already exists.");
+
+            var newTopology = sessionTopology.AddExplicitSession(explicitSession);
+            return Task.FromResult(newTopology.JsonSerialize());
+        }
+
+        public Task<string> SessionExplicitRemove(Dictionary<string, object> parameters)
+        {
+            var explicitSessionAddress = new Address((string)parameters["explicitSession"]);
+            var sessionTopology = SessionsTopology.FromJson(parameters["sessionTopology"].ToString());
+            var newTopology = sessionTopology.RemoveExplicitSession(explicitSessionAddress);
+
+            return Task.FromResult(newTopology.JsonSerialize());
+        }
+
+        public Task<string> SessionImplicitAddBlacklistAddress(Dictionary<string, object> parameters)
+        {
+            var blacklistAddress = new Address((string)parameters["blacklistAddress"]);
+            var sessionTopologyJson = parameters["sessionTopology"].ToString();
+
+            var sessionsTopology = SessionsTopology.FromJson(sessionTopologyJson);
+            sessionsTopology.AddToImplicitBlacklist(blacklistAddress);
+
+            return Task.FromResult(sessionsTopology.JsonSerialize());
+        }
+
+        public Task<string> SessionImplicitRemoveBlacklistAddress(Dictionary<string, object> parameters)
+        {
+            var address = new Address((string)parameters["address"]);
+            var sessionTopology = SessionsTopology.FromJson(parameters["sessionTopology"].ToString());
+            sessionTopology.RemoveFromImplicitBlacklist(address);
+
+            return Task.FromResult(sessionTopology.JsonSerialize());
+        }
+    }
+}

Assets/SequenceSDK/EcosystemWallet/IntegrationTests/SignatureTests.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Sequence.EcosystemWallet.Primitives;
+using Sequence.EcosystemWallet.Utils;
+using Sequence.Utils;
+using UnityEngine;
+
+namespace Sequence.EcosystemWallet.IntegrationTests
+{
+    public class SignatureTests
+    {
+        public Task<string> SignatureEncode(Dictionary<string, object> parameters)
+        {
+            var input = parameters["input"].ToString();
+            var signatures = parameters["signatures"].ToString();
+            var noChainId = !parameters.TryGetValue("chainId", out var chainIdValue) || !(bool)chainIdValue;
+            var checkpointerData = parameters.TryGetValue("checkpointerData", out var checkpointerDataValue) ? 
+                checkpointerDataValue.ToString().HexStringToByteArray() : null;
+
+            return Task.FromResult(SignatureUtils.EncodeSignatureFromInput(input, signatures, noChainId, checkpointerData));
+        }
+
+        public Task<string> SignatureDecode(Dictionary<string, object> parameters)
+        {
+            var encodedSignature = parameters["signature"].ToString().HexStringToByteArray();
+            var signature = RawSignature.Decode(encodedSignature);
+
+            return Task.FromResult(signature.ToJson());
+        }
+
+        public Task<string> SignatureConcat(Dictionary<string, object> parameters)
+        {
+            var signatures = parameters.GetArray<string>("signatures");
+            var decoded = signatures.Select(signature => 
+                    RawSignature.Decode(signature.HexStringToByteArray())).ToArray();
+
+            var parentSignature = decoded[0];
+            parentSignature.suffix = decoded.Slice(1);
+            var encoded = parentSignature.Encode();
+
+            return Task.FromResult(encoded.ByteArrayToHexStringWithPrefix());
+        }
+    }
+}