default session saving completed & tested

Core Modules/WalletConnectSharp.Crypto/KeyChain.cs

@@ -193,7 +193,9 @@ private async Task<Dictionary<string, string>> GetKeyChain()
 
         private async Task SaveKeyChain()
         {
-            await Storage.SetItem(StorageKey, this._keyChain);
+            // We need to copy the contents, otherwise Dispose()
+            // may clear the reference stored inside InMemoryStorage
+            await Storage.SetItem(StorageKey, new Dictionary<string, string>(this._keyChain));
         }
 
         public void Dispose()

Core Modules/WalletConnectSharp.Storage/FileSystemStorage.cs

@@ -88,38 +88,65 @@ private async Task Save()
                 Directory.CreateDirectory(path);
             }
 
-            var json = JsonConvert.SerializeObject(Entries,
-                new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All });
+            string json;
+            lock (entriesLock)
+            {
+                json = JsonConvert.SerializeObject(Entries,
+                    new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All });
+            }
 
-            await _semaphoreSlim.WaitAsync();
-            await File.WriteAllTextAsync(FilePath, json, Encoding.UTF8);
-            _semaphoreSlim.Release();
+            try
+            {
+                if (!Disposed)
+                    await _semaphoreSlim.WaitAsync();
+                int count = 5;
+                IOException lastException;
+                do
+                {
+                    try
+                    {
+                        await File.WriteAllTextAsync(FilePath, json, Encoding.UTF8);
+                        return;
+                    }
+                    catch (IOException e)
+                    {
+                        WCLogger.LogError($"Got error saving storage file: retries left {count}");
+                        await Task.Delay(100);
+                        count--;
+                        lastException = e;
+                    }
+                } while (count > 0);
+
+                throw lastException;
+            }
+            finally
+            {
+                if (!Disposed)
+                    _semaphoreSlim.Release();
+            }
         }
 
         private async Task Load()
         {
             if (!File.Exists(FilePath))
                 return;
 
-            await _semaphoreSlim.WaitAsync();
-            var json = await File.ReadAllTextAsync(FilePath, Encoding.UTF8);
-            _semaphoreSlim.Release();
-
+            string json;
             try
             {
-                Entries = JsonConvert.DeserializeObject<Dictionary<string, object>>(json,
-                    new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.Auto });
+                await _semaphoreSlim.WaitAsync();
+                json = await File.ReadAllTextAsync(FilePath, Encoding.UTF8);
             }
-            catch (JsonSerializationException e)
+            finally
             {
-                // Move the file to a .unsupported file
-                // and start fresh
-                WCLogger.LogError(e);
-                WCLogger.LogError("Cannot load JSON file, moving data to .unsupported file to force continue");
-                if (File.Exists(FilePath + ".unsupported"))
-                    File.Move(FilePath + ".unsupported", FilePath + "." + Guid.NewGuid() + ".unsupported");
-                File.Move(FilePath, FilePath + ".unsupported");
-                Entries = new Dictionary<string, object>();
+                _semaphoreSlim.Release();
+            }
+
+            // Hard fail here if the storage file is bad
+            lock (entriesLock)
+            {
+                Entries = JsonConvert.DeserializeObject<Dictionary<string, object>>(json,
+                    new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.Auto });
             }
         }
 

Core Modules/WalletConnectSharp.Storage/InMemoryStorage.cs

@@ -5,6 +5,7 @@ namespace WalletConnectSharp.Storage
 {
     public class InMemoryStorage : IKeyValueStorage
     {
+        protected readonly object entriesLock = new object();
         protected Dictionary<string, object> Entries = new Dictionary<string, object>();
         private bool _initialized = false;
         protected bool Disposed;
@@ -18,51 +19,76 @@ public virtual Task Init()
         public virtual Task<string[]> GetKeys()
         {
             IsInitialized();
-            return Task.FromResult(Entries.Keys.ToArray());
+            lock (entriesLock)
+            {
+                return Task.FromResult(Entries.Keys.ToArray());
+            }
         }
 
         public virtual async Task<T[]> GetEntriesOfType<T>()
         {
             IsInitialized();
+            // GetEntries is thread-safe
             return (await GetEntries()).OfType<T>().ToArray();
         }
 
         public virtual Task<object[]> GetEntries()
         {
             IsInitialized();
-            return Task.FromResult(Entries.Values.ToArray());
+            lock (entriesLock)
+            {
+                return Task.FromResult(Entries.Values.ToArray());
+            }
         }
 
         public virtual Task<T> GetItem<T>(string key)
         {
             IsInitialized();
-            return Task.FromResult(Entries[key] is T ? (T)Entries[key] : default);
+            lock (entriesLock)
+            {
+                return Task.FromResult(Entries[key] is T ? (T)Entries[key] : default);
+            }
         }
 
         public virtual Task SetItem<T>(string key, T value)
         {
             IsInitialized();
-            Entries[key] = value;
+            lock (entriesLock)
+            {
+                Entries[key] = value;
+            }
+
             return Task.CompletedTask;
         }
 
         public virtual Task RemoveItem(string key)
         {
             IsInitialized();
-            Entries.Remove(key);
+            lock (entriesLock)
+            {
+                Entries.Remove(key);
+            }
+
             return Task.CompletedTask;
         }
 
         public virtual Task<bool> HasItem(string key)
         {
             IsInitialized();
-            return Task.FromResult(Entries.ContainsKey(key));
+            lock (entriesLock)
+            {
+                return Task.FromResult(Entries.ContainsKey(key));
+            }
         }
 
         public virtual Task Clear()
         {
             IsInitialized();
-            Entries.Clear();
+            lock (entriesLock)
+            {
+                Entries.Clear();
+            }
+
             return Task.CompletedTask;
         }
 

Tests/WalletConnectSharp.Auth.Tests/AuthClientTest.cs

@@ -11,6 +11,7 @@
 using WalletConnectSharp.Storage;
 using WalletConnectSharp.Tests.Common;
 using Xunit;
+using Xunit.Abstractions;
 using ErrorResponse = WalletConnectSharp.Auth.Models.ErrorResponse;
 
 namespace WalletConnectSharp.Auth.Tests
@@ -26,6 +27,7 @@ public class AuthClientTests : IClassFixture<CryptoWalletFixture>, IAsyncLifetim
         };
 
         private readonly CryptoWalletFixture _cryptoWalletFixture;
+        private readonly ITestOutputHelper _testOutputHelper;
 
         private IAuthClient PeerA;
         public IAuthClient PeerB;
@@ -54,9 +56,10 @@ public string WalletAddress
             }
         }
 
-        public AuthClientTests(CryptoWalletFixture cryptoFixture)
+        public AuthClientTests(CryptoWalletFixture cryptoFixture, ITestOutputHelper testOutputHelper)
         {
             this._cryptoWalletFixture = cryptoFixture;
+            _testOutputHelper = testOutputHelper;
         }
 
         [Fact, Trait("Category", "unit")]
@@ -120,7 +123,7 @@ public async void TestKnownPairings()
             var ogHistorySizeB = historyB.Keys.Length;
 
             List<TopicMessage> responses = new List<TopicMessage>();
-            TaskCompletionSource<TopicMessage> responseTask = new TaskCompletionSource<TopicMessage>();
+            TaskCompletionSource<TopicMessage> knownPairingTask = new TaskCompletionSource<TopicMessage>();
 
             async void OnPeerBOnAuthRequested(object sender, AuthRequest request)
             {
@@ -139,9 +142,9 @@ void OnPeerAOnAuthResponded(object sender, AuthResponse args)
                 var sessionTopic = args.Topic;
                 var cacao = args.Response.Result;
                 var signature = cacao.Signature;
-                Console.WriteLine($"{sessionTopic}: {signature}");
+                _testOutputHelper.WriteLine($"{sessionTopic}: {signature}");
                 responses.Add(args);
-                responseTask.SetResult(args);
+                knownPairingTask.SetResult(args);
             }
 
             PeerA.AuthResponded += OnPeerAOnAuthResponded;
@@ -150,9 +153,9 @@ void OnPeerAOnAuthError(object sender, AuthErrorResponse args)
             {
                 var sessionTopic = args.Topic;
                 var error = args.Error;
-                Console.WriteLine($"{sessionTopic}: {error}");
+                _testOutputHelper.WriteLine($"{sessionTopic}: {error}");
                 responses.Add(args);
-                responseTask.SetResult(args);
+                knownPairingTask.SetResult(args);
             }
 
             PeerA.AuthError += OnPeerAOnAuthError;
@@ -161,17 +164,17 @@ void OnPeerAOnAuthError(object sender, AuthErrorResponse args)
 
             await PeerB.Core.Pairing.Pair(requestData.Uri);
 
-            await responseTask.Task;
+            await knownPairingTask.Task;
 
             // Reset
-            responseTask = new TaskCompletionSource<TopicMessage>();
+            knownPairingTask = new TaskCompletionSource<TopicMessage>();
 
             // Get last pairing, that is the one we just made
             var knownPairing = PeerA.Core.Pairing.Pairings[^1];
 
             var requestData2 = await PeerA.Request(DefaultRequestParams, knownPairing.Topic);
 
-            await responseTask.Task;
+            await knownPairingTask.Task;
 
             Assert.Null(requestData2.Uri);
 

Tests/WalletConnectSharp.Sign.Test/SignClientFixture.cs

@@ -1,12 +1,16 @@
 using WalletConnectSharp.Core;
 using WalletConnectSharp.Sign.Models;
 using WalletConnectSharp.Storage;
+using WalletConnectSharp.Storage.Interfaces;
 using WalletConnectSharp.Tests.Common;
 
 namespace WalletConnectSharp.Sign.Test;
 
 public class SignClientFixture : TwoClientsFixture<WalletConnectSignClient>
 {
+    public IKeyValueStorage StorageOverrideA;
+    public IKeyValueStorage StorageOverrideB;
+
     public SignClientOptions OptionsA { get; protected set; }
     public SignClientOptions OptionsB { get;  protected set; }
 
@@ -26,11 +30,11 @@ public override async Task Init()
             {
                 Description = "An example dapp to showcase WalletConnectSharpv2",
                 Icons = new[] { "https://walletconnect.com/meta/favicon.ico" },
-                Name = $"WalletConnectSharpv2 Dapp Example - {Guid.NewGuid().ToString()}",
+                Name = $"WalletConnectSharpv2 Dapp Example",
                 Url = "https://walletconnect.com"
             },
             // Omit if you want persistant storage
-            Storage = new InMemoryStorage()
+            Storage = StorageOverrideA ?? new InMemoryStorage()
         };
 
         OptionsB = new SignClientOptions()
@@ -41,14 +45,16 @@ public override async Task Init()
             {
                 Description = "An example wallet to showcase WalletConnectSharpv2",
                 Icons = new[] { "https://walletconnect.com/meta/favicon.ico" },
-                Name = $"WalletConnectSharpv2 Wallet Example - {Guid.NewGuid().ToString()}",
+                Name = $"WalletConnectSharpv2 Wallet Example",
                 Url = "https://walletconnect.com"
             },
             // Omit if you want persistant storage
-            Storage = new InMemoryStorage()
+            Storage = StorageOverrideB ?? new InMemoryStorage()
         };
 
         ClientA = await WalletConnectSignClient.Init(OptionsA);
         ClientB = await WalletConnectSignClient.Init(OptionsB);
     }
+
+
 }