Merge branch '2.0' into dependabot/nuget/xunit.runner.visualstudio-2.5.0

Core Modules/WalletConnectSharp.Common/IModule.cs

@@ -5,7 +5,7 @@ namespace WalletConnectSharp.Common
     /// <summary>
     /// An interface that represents a module
     /// </summary>
-    public interface IModule /* : IDisposable */
+    public interface IModule : IDisposable
     {
         /// <summary>
         /// The name of this module
@@ -18,4 +18,4 @@ public interface IModule /* : IDisposable */
         /// </summary>
         string Context { get; }
     }
-}
+}

Core Modules/WalletConnectSharp.Common/Logging/ILogger.cs

@@ -0,0 +1,11 @@
+namespace WalletConnectSharp.Common.Logging
+{
+    public interface ILogger
+    {
+        void Log(string message);
+
+        void LogError(string message);
+
+        void LogError(Exception e);
+    }
+}

Core Modules/WalletConnectSharp.Common/Logging/WCLogger.cs

@@ -0,0 +1,36 @@
+namespace WalletConnectSharp.Common.Logging
+{
+    public class WCLogger
+    {
+        public static ILogger Logger;
+
+        public static ILogger WithContext(string context)
+        {
+            return new WrapperLogger(Logger, context);
+        }
+
+        public static void Log(string message)
+        {
+            if (Logger == null)
+                return;
+
+            Logger.Log(message);
+        }
+
+        public static void LogError(string message)
+        {
+            if (Logger == null)
+                return;
+
+            Logger.LogError(message);
+        }
+
+        public static void LogError(Exception e)
+        {
+            if (Logger == null)
+                return;
+
+            Logger.LogError(e);
+        }
+    }
+}

Core Modules/WalletConnectSharp.Common/Logging/WrapperLogger.cs

@@ -0,0 +1,31 @@
+namespace WalletConnectSharp.Common.Logging;
+
+public class WrapperLogger : ILogger
+{
+    private ILogger _logger;
+    private string prefix;
+
+    public WrapperLogger(ILogger logger, string prefix)
+    {
+        _logger = logger;
+        this.prefix = prefix;
+    }
+
+    public void Log(string message)
+    {
+        if (_logger == null) return;
+        _logger.Log($"[{prefix}] {message}");
+    }
+
+    public void LogError(string message)
+    {
+        if (_logger == null) return;
+        _logger.LogError($"[{prefix}] {message}");
+    }
+
+    public void LogError(Exception e)
+    {
+        if (_logger == null) return;
+        _logger.LogError(e);
+    }
+}

Core Modules/WalletConnectSharp.Common/Model/Errors/SdkErrors.cs

@@ -27,9 +27,9 @@ public static class SdkErrors
         /// <param name="type">The error type message to generate</param>
         /// <param name="params">A dictionary (or anonymous type) of parameters for the error message</param>
         /// <returns>The error message as a string</returns>
-        public static string MessageFromType(ErrorType type, object @params = null)
+        public static string MessageFromType(ErrorType type, Dictionary<string, object> @params = null)
         {
-            return MessageFromType(type, null, @params.AsDictionary());
+            return MessageFromType(type, null, @params);
         }
 
         /// <summary>
@@ -47,8 +47,8 @@ public static string MessageFromType(ErrorType type, string message = null, Dict
                 @params = new Dictionary<string, object>();
             }
 
-            if (!string.IsNullOrWhiteSpace(message) && !@params.ContainsKey("message"))
-                @params.Add("message", message);
+            if (!string.IsNullOrWhiteSpace(message))
+                @params.TryAdd("message", message);
 
             string errorMessage;
             switch (type)
@@ -231,4 +231,4 @@ private static string FormatErrorText(string formattedText, Dictionary<string, o
             return text;
         }
     }
-}
+}

Core Modules/WalletConnectSharp.Common/Model/Errors/WalletConnectException.cs

@@ -84,9 +84,9 @@ public static WalletConnectException FromType(ErrorType type, string message = n
         /// <param name="type">The error type of the exception</param>
         /// <param name="params">Additional (optional) parameters for the generated error message</param>
         /// <returns>A new exception</returns>
-        public static WalletConnectException FromType(ErrorType type, object @params = null)
+        public static WalletConnectException FromType(ErrorType type, Dictionary<string, object> @params = null)
         {
-            return FromType(type, null, @params.AsDictionary());
+            return FromType(type, null, @params);
         }
     }
-}
+}

Core Modules/WalletConnectSharp.Common/Model/IsolatedModule.cs

@@ -38,5 +38,7 @@ public IsolatedModule()
 
             activeModules.Add(_guid);
         }
+
+        public void Dispose() { }
     }
-}
+}

Core Modules/WalletConnectSharp.Common/Utils/Clock.cs

@@ -164,5 +164,19 @@ public static long Now()
         {
             return ((DateTimeOffset)DateTime.Now).ToUnixTimeSeconds();
         }
+
+        /// <summary>
+        /// Current DateTime.Now as unix timestamp milliseconds
+        /// </summary>
+        /// <returns></returns>
+        public static long NowMilliseconds()
+        {
+            return ((DateTimeOffset)DateTime.Now).ToUnixTimeMilliseconds();
+        }
+
+        public static TimeSpan AsTimeSpan(long seconds)
+        {
+            return TimeSpan.FromSeconds(seconds);
+        }
     }
-}
+}

Core Modules/WalletConnectSharp.Common/Utils/DictionaryComparer.cs

@@ -0,0 +1,30 @@
+namespace WalletConnectSharp.Common.Utils
+{
+    public class DictionaryComparer<TKey, TValue> :
+        IEqualityComparer<Dictionary<TKey, TValue>>
+    {
+        private IEqualityComparer<TValue> valueComparer;
+        public DictionaryComparer(IEqualityComparer<TValue> valueComparer = null)
+        {
+            this.valueComparer = valueComparer ?? EqualityComparer<TValue>.Default;
+        }
+        public bool Equals(Dictionary<TKey, TValue> x, Dictionary<TKey, TValue> y)
+        {
+            if (x.Count != y.Count)
+                return false;
+            if (x.Keys.Except(y.Keys).Any())
+                return false;
+            if (y.Keys.Except(x.Keys).Any())
+                return false;
+            foreach (var pair in x)
+                if (!valueComparer.Equals(pair.Value, y[pair.Key]))
+                    return false;
+            return true;
+        }
+
+        public int GetHashCode(Dictionary<TKey, TValue> obj)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Core Modules/WalletConnectSharp.Common/Utils/Extensions.cs

@@ -11,34 +11,6 @@ namespace WalletConnectSharp.Common.Utils
     /// </summary>
     public static class Extensions
     {
-        /// <summary>
-        /// Convert an anonymous type to a Dictionary
-        /// </summary>
-        /// <param name="obj">The anonymous type instance to convert to a dictionary</param>
-        /// <param name="enforceLowercase">Enforce all keys to be lowercased</param>
-        /// <returns>A dictionary where each key is the property name of the anonymous type
-        /// and each value is the property's value</returns>
-        public static Dictionary<string, object> AsDictionary(this object obj, bool enforceLowercase = true)
-        {
-            if (obj is Dictionary<string, object> objects)
-                return objects;
-
-            var dict = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
-
-            if (obj != null)
-            {
-                foreach (PropertyInfo propertyDescriptor in obj.GetType().GetProperties())
-                {
-                    object value = propertyDescriptor.GetValue(obj, null);
-                    var key = enforceLowercase ? propertyDescriptor.Name.ToLower() : propertyDescriptor.Name;
-
-                    dict.Add(key, value);
-                }
-            }
-
-            return dict;
-        }
-
         /// <summary>
         /// Returns true if the given object is a numeric type
         /// </summary>
@@ -129,5 +101,12 @@ public static async Task WithTimeout(this Task task, TimeSpan timeout, string me
                 throw new TimeoutException(message.Replace("%t", timeout.ToString()));
             }
         }
+
+        public static bool SetEquals<T>(this IEnumerable<T> first, IEnumerable<T> second,
+            IEqualityComparer<T> comparer)
+        {
+            return new HashSet<T>(second, comparer ?? EqualityComparer<T>.Default)
+                .SetEquals(first);
+        }
     }
-}
+}

Core Modules/WalletConnectSharp.Common/Utils/ListComparer.cs

@@ -0,0 +1,21 @@
+namespace WalletConnectSharp.Common.Utils
+{
+    public class ListComparer<T> : IEqualityComparer<List<T>>
+    {
+        private IEqualityComparer<T> valueComparer;
+        public ListComparer(IEqualityComparer<T> valueComparer = null)
+        {
+            this.valueComparer = valueComparer ?? EqualityComparer<T>.Default;
+        }
+
+        public bool Equals(List<T> x, List<T> y)
+        {
+            return x.SetEquals(y, valueComparer);
+        }
+
+        public int GetHashCode(List<T> obj)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Core Modules/WalletConnectSharp.Crypto/Crypto.cs

@@ -43,8 +43,8 @@ public class Crypto : ICrypto
         private static readonly Encoding DATA_ENCODING = Encoding.UTF8;
         private static readonly Encoding JSON_ENCODING = Encoding.UTF8;
 
-        private const int TYPE_0 = 0;
-        private const int TYPE_1 = 1;
+        public const int TYPE_0 = 0;
+        public const int TYPE_1 = 1;
         private const int TYPE_LENGTH = 1;
         private const int IV_LENGTH = 12;
         private const int KEY_LENGTH = 32;
@@ -578,11 +578,20 @@ private void IsInitialized()
         {
             if (!this._initialized)
             {
-                throw WalletConnectException.FromType(ErrorType.NOT_INITIALIZED, new {Name});
+                throw WalletConnectException.FromType(ErrorType.NOT_INITIALIZED, new Dictionary<string, object>()
+                {
+                    { "Name", Name }
+                });
             }
         }
 
-        private string HashKey(string key)
+        /// <summary>
+        /// Hash a hex key string using SHA256. The input key string must be a hex
+        /// string and the returned hash is represented as a hex string
+        /// </summary>
+        /// <param name="key">The input hex key string to hash using SHA256</param>
+        /// <returns>The hash of the given input as a hex string</returns>
+        public string HashKey(string key)
         {
             using (SHA256 sha256 = SHA256.Create())
             {
@@ -675,5 +684,10 @@ private async Task<byte[]> GetClientSeed()
 
             return seed.HexToByteArray();
         }
+
+        public void Dispose()
+        {
+            KeyChain?.Dispose();
+        }
     }
 }

Core Modules/WalletConnectSharp.Crypto/Interfaces/ICrypto.cs

@@ -121,5 +121,13 @@ public interface ICrypto : IModule
         /// </summary>
         /// <returns>The client id as a string</returns>
         Task<string> GetClientId();
+
+        /// <summary>
+        /// Hash a hex key string using SHA256. The input key string must be a hex
+        /// string and the returned hash is represented as a hex string
+        /// </summary>
+        /// <param name="key">The input hex key string to hash using SHA256</param>
+        /// <returns>The hash of the given input as a hex string</returns>
+        string HashKey(string key);
     }
 }

Core Modules/WalletConnectSharp.Crypto/KeyChain.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.Threading.Tasks;
-using WalletConnectSharp.Common;
 using WalletConnectSharp.Common.Model.Errors;
 using WalletConnectSharp.Common.Utils;
 using WalletConnectSharp.Crypto.Interfaces;
@@ -142,7 +138,10 @@ public async Task<string> Get(string tag)
 
             if (!await Has(tag))
             {
-                throw WalletConnectException.FromType(ErrorType.NO_MATCHING_KEY, new {tag});
+                throw WalletConnectException.FromType(ErrorType.NO_MATCHING_KEY, new Dictionary<string, object>()
+                {
+                    {"tag", tag}
+                });
             }
 
             return this._keyChain[tag];
@@ -160,7 +159,10 @@ public async Task Delete(string tag)
 
             if (!await Has(tag))
             {
-                throw WalletConnectException.FromType(ErrorType.NO_MATCHING_KEY, new {tag});
+                throw WalletConnectException.FromType(ErrorType.NO_MATCHING_KEY, new Dictionary<string, object>()
+                {
+                    {"tag", tag}
+                });
             }
 
             _keyChain.Remove(tag);
@@ -172,7 +174,10 @@ private void IsInitialized()
         {
             if (!this._initialized)
             {
-                throw WalletConnectException.FromType(ErrorType.NOT_INITIALIZED, new {Name});
+                throw WalletConnectException.FromType(ErrorType.NOT_INITIALIZED, new Dictionary<string, object>()
+                {
+                    {"Name", Name}
+                });
             }
         }
 
@@ -190,5 +195,11 @@ private async Task SaveKeyChain()
         {
             await Storage.SetItem(StorageKey, this._keyChain);
         }
+
+        public void Dispose()
+        {
+            _keyChain?.Clear();
+            Storage?.Dispose();
+        }
     }
 }

Core Modules/WalletConnectSharp.Crypto/Models/DecodeOptions.cs

@@ -11,6 +11,6 @@ public class DecodeOptions
         /// The public key that received this encoded message
         /// </summary>
         [JsonProperty("receiverPublicKey")]
-        public string ReceiverPublicKey { get; set; }
+        public string ReceiverPublicKey;
     }
 }