Fix/mwa keep connection alive auth token restore

Runtime/codebase/SolanaMobileStack/Interfaces/IAdapterOperations.cs

@@ -13,6 +13,10 @@ public interface IAdapterOperations
     [Preserve]
     public Task<AuthorizationResult> Reauthorize(Uri identityUri, Uri iconUri, string identityName, string authToken);
     [Preserve]
+    public Task Deauthorize(string authToken);
+    [Preserve]
+    public Task<CapabilitiesResult> GetCapabilities();
+    [Preserve]
     public Task<SignedResult> SignTransactions(IEnumerable<byte[]> transactions);
     [Preserve]
     public Task<SignedResult> SignMessages(IEnumerable<byte[]> messages, IEnumerable<byte[]> addresses);

Runtime/codebase/SolanaMobileStack/JsonRpcClient/Responses/CapabilitiesResult.cs

@@ -0,0 +1,20 @@
+using Newtonsoft.Json;
+using UnityEngine.Scripting;
+
+// ReSharper disable once CheckNamespace
+
+[Preserve]
+public class CapabilitiesResult
+{
+    [JsonProperty("supports_clone_authorization")]
+    public bool? SupportsCloneAuthorization { get; set; }
+
+    [JsonProperty("max_transactions_per_request")]
+    public int? MaxTransactionsPerRequest { get; set; }
+
+    [JsonProperty("max_messages_per_request")]
+    public int? MaxMessagesPerRequest { get; set; }
+
+    [JsonProperty("supported_transaction_versions")]
+    public string[] SupportedTransactionVersions { get; set; }
+}

Runtime/codebase/SolanaMobileStack/MobileWalletAdapterClient.cs

@@ -44,6 +44,18 @@ public Task<AuthorizationResult> Reauthorize(Uri identityUri, Uri iconUri, strin
 
         return SendRequest<AuthorizationResult>(request);
     }
+
+    public async Task Deauthorize(string authToken)
+    {
+        var request = PrepareDeauthorizeRequest(authToken);
+        await SendRequest<object>(request);
+    }
+
+    public Task<CapabilitiesResult> GetCapabilities()
+    {
+        var request = PrepareGetCapabilitiesRequest();
+        return SendRequest<CapabilitiesResult>(request);
+    }
 
     public Task<SignedResult> SignTransactions(IEnumerable<byte[]> transactions)
     {
@@ -85,6 +97,33 @@ private JsonRequest PrepareAuthRequest(Uri uriIdentity, Uri icon, string name, s
         };
         return request;
     }
+
+    private JsonRequest PrepareDeauthorizeRequest(string authToken)
+    {
+        var request = new JsonRequest
+        {
+            JsonRpc = "2.0",
+            Method = "deauthorize",
+            Params = new JsonRequest.JsonRequestParams
+            {
+                AuthToken = authToken
+            },
+            Id = NextMessageId()
+        };
+        return request;
+    }
+
+    private JsonRequest PrepareGetCapabilitiesRequest()
+    {
+        var request = new JsonRequest
+        {
+            JsonRpc = "2.0",
+            Method = "get_capabilities",
+            Params = new JsonRequest.JsonRequestParams(),
+            Id = NextMessageId()
+        };
+        return request;
+    }
 
     private JsonRequest PrepareSignTransactionsRequest(IEnumerable<byte[]> transactions)
     {

Runtime/codebase/SolanaMobileStack/SolanaMobileWalletAdapter.cs

@@ -34,6 +34,9 @@ public class SolanaMobileWalletAdapter : WalletBase
         private readonly WalletBase _internalWallet;
         private string _authToken;
 
+        public event Action OnWalletDisconnected;
+        public event Action OnWalletReconnected;
+
         public SolanaMobileWalletAdapter(
             SolanaMobileWalletAdapterOptions solanaWalletOptions,
             RpcCluster rpcCluster = RpcCluster.DevNet, 
@@ -54,7 +57,56 @@ protected override async Task<Account> _Login(string password = null)
             if (_walletOptions.keepConnectionAlive)
             {
                 string pk = PlayerPrefs.GetString("pk", null);
-                if (!pk.IsNullOrEmpty()) return new Account(string.Empty, new PublicKey(pk));
+                string authToken = PlayerPrefs.GetString("authToken", null);
+                if (!pk.IsNullOrEmpty() && !authToken.IsNullOrEmpty())
+                {
+                    string reauthPublicKey = null;
+                    // TODO: change to using var after PR #260 merges (IDisposable not yet on LocalAssociationScenario)
+                    var reauthorizeScenario = new LocalAssociationScenario();
+                    var reauthorizeResult = await reauthorizeScenario.StartAndExecute(
+                        new List<Action<IAdapterOperations>>
+                        {
+                            async client =>
+                            {
+                                var reauth = await client.Reauthorize(
+                                    new Uri(_walletOptions.identityUri),
+                                    new Uri(_walletOptions.iconUri, UriKind.Relative),
+                                    _walletOptions.name, authToken);
+                                if (reauth != null && !string.IsNullOrEmpty(reauth.AuthToken))
+                                {
+                                    _authToken = reauth.AuthToken;
+                                    reauthPublicKey = reauth.PublicKey != null
+                                        ? new PublicKey(reauth.PublicKey).ToString()
+                                        : null;
+                                }
+                            }
+                        }
+                    );
+                    if (reauthorizeResult.WasSuccessful)
+                    {
+                        if (string.IsNullOrEmpty(_authToken))
+                        {
+                            // Reauthorize RPC succeeded but wallet returned no token - treat as failure
+                            // Fall through to cleanup below
+                        }
+                        else
+                        {
+                            PlayerPrefs.SetString("authToken", _authToken);
+                            PlayerPrefs.Save();
+                            var resolvedKey = !string.IsNullOrEmpty(reauthPublicKey) ? reauthPublicKey : pk;
+                            return new Account(string.Empty, new PublicKey(resolvedKey));
+                        }
+                    }
+                    // Reauthorize failed or returned empty token - clear cached credentials
+                    PlayerPrefs.DeleteKey("pk");
+                    PlayerPrefs.DeleteKey("authToken");
+                    PlayerPrefs.Save();
+                }
+                else if (!pk.IsNullOrEmpty())
+                {
+                    PlayerPrefs.DeleteKey("pk");
+                    PlayerPrefs.Save();
+                }
             }
             AuthorizationResult authorization = null;
             var localAssociationScenario = new LocalAssociationScenario();
@@ -76,11 +128,17 @@ protected override async Task<Account> _Login(string password = null)
                 Debug.LogError(result.Error.Message);
                 throw new Exception(result.Error.Message);
             }
+            if (authorization == null)
+            {
+                throw new Exception("[MWA] Login: authorization was not populated");
+            }
             _authToken = authorization.AuthToken;
             var publicKey = new PublicKey(authorization.PublicKey);
             if (_walletOptions.keepConnectionAlive)
             {
                 PlayerPrefs.SetString("pk", publicKey.ToString());
+                PlayerPrefs.SetString("authToken", _authToken);
+                PlayerPrefs.Save();
             }
             return new Account(string.Empty, publicKey);
         }
@@ -94,6 +152,8 @@ protected override async Task<Transaction> _SignTransaction(Transaction transact
 
         protected override async Task<Transaction[]> _SignAllTransactions(Transaction[] transactions)
         {
+            if (_authToken.IsNullOrEmpty() && _walletOptions.keepConnectionAlive)
+                _authToken = PlayerPrefs.GetString("authToken", null);
 
             var cluster = RPCNameMap[(int)RpcCluster];
             SignedResult res = null;
@@ -130,7 +190,20 @@ protected override async Task<Transaction[]> _SignAllTransactions(Transaction[]
                 Debug.LogError(result.Error.Message);
                 throw new Exception(result.Error.Message);
             }
+            if (authorization == null)
+            {
+                throw new Exception("[MWA] SignAllTransactions: authorization was not populated");
+            }
+            if (res == null)
+            {
+                throw new Exception("[MWA] SignAllTransactions: signed payloads were not populated");
+            }
             _authToken = authorization.AuthToken;
+            if (_walletOptions.keepConnectionAlive)
+            {
+                PlayerPrefs.SetString("authToken", _authToken);
+                PlayerPrefs.Save();
+            }
             return res.SignedPayloads.Select(transaction => Transaction.Deserialize(transaction)).ToArray();
         }
 
@@ -139,11 +212,105 @@ public override void Logout()
         {
             base.Logout();
             PlayerPrefs.DeleteKey("pk");
+            _authToken = null;
+            PlayerPrefs.DeleteKey("authToken");
             PlayerPrefs.Save();
         }
 
+        public async Task DisconnectWallet()
+        {
+            string authToken = _authToken;
+            if (authToken.IsNullOrEmpty())
+                authToken = PlayerPrefs.GetString("authToken", null);
+
+            if (!authToken.IsNullOrEmpty())
+            {
+                try
+                {
+                    // TODO: change to using var after PR #260 merges (IDisposable not yet on LocalAssociationScenario)
+                    var localAssociationScenario = new LocalAssociationScenario();
+                    var result = await localAssociationScenario.StartAndExecute(
+                        new List<Action<IAdapterOperations>>
+                        {
+                            async client =>
+                            {
+                                await client.Deauthorize(authToken);
+                            }
+                        }
+                    );
+                    if (!result.WasSuccessful)
+                    {
+                        Debug.LogWarning($"[MWA] Deauthorize returned error: {result.Error.Message}");
+                    }
+                }
+                catch (Exception e)
+                {
+                    Debug.LogWarning($"[MWA] Deauthorize transport failed (best-effort): {e}");
+                }
+            }
+
+            Logout();
+            OnWalletDisconnected?.Invoke();
+        }
+
+        public async Task ReconnectWallet()
+        {
+            try
+            {
+                var account = await Login();
+                if (account != null)
+                {
+                    OnWalletReconnected?.Invoke();
+                }
+                else
+                {
+                    Debug.LogWarning("[MWA] ReconnectWallet: Login returned null, not firing OnWalletReconnected");
+                    throw new Exception("ReconnectWallet failed: Login returned null");
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.LogError(e.Message);
+                throw;
+            }
+        }
+
+        public async Task<CapabilitiesResult> GetCapabilities()
+        {
+            CapabilitiesResult capabilities = null;
+            // TODO: change to using var after PR #260 merges (IDisposable not yet on LocalAssociationScenario)
+            var localAssociationScenario = new LocalAssociationScenario();
+            var result = await localAssociationScenario.StartAndExecute(
+                new List<Action<IAdapterOperations>>
+                {
+                    async client =>
+                    {
+                        capabilities = await client.GetCapabilities();
+                    }
+                }
+            );
+            if (!result.WasSuccessful)
+            {
+                Debug.LogError(result.Error.Message);
+                throw new Exception(result.Error.Message);
+            }
+            if (capabilities == null)
+            {
+                throw new Exception("[MWA] GetCapabilities RPC succeeded but returned no data");
+            }
+            return capabilities;
+        }
+
         public override async Task<byte[]> SignMessage(byte[] message)
         {
+            if (_authToken.IsNullOrEmpty() && _walletOptions.keepConnectionAlive)
+                _authToken = PlayerPrefs.GetString("authToken", null);
+
+            string cachedPk = Account?.PublicKey?.ToString()
+                ?? PlayerPrefs.GetString("pk", null);
+            if (string.IsNullOrEmpty(cachedPk))
+                throw new Exception("[MWA] Cannot sign message: no account available");
+
             SignedResult signedMessages = null;
             var localAssociationScenario = new LocalAssociationScenario();
             AuthorizationResult authorization = null;
@@ -172,7 +339,7 @@ public override async Task<byte[]> SignMessage(byte[] message)
                     {
                         signedMessages = await client.SignMessages(
                             messages: new List<byte[]> { message },
-                            addresses: new List<byte[]> { Account.PublicKey.KeyBytes }
+                            addresses: new List<byte[]> { new PublicKey(cachedPk).KeyBytes }
                         );
                     }
                 }
@@ -182,7 +349,20 @@ public override async Task<byte[]> SignMessage(byte[] message)
                 Debug.LogError(result.Error.Message);
                 throw new Exception(result.Error.Message);
             }
+            if (authorization == null)
+            {
+                throw new Exception("[MWA] SignMessage: authorization was not populated");
+            }
+            if (signedMessages == null)
+            {
+                throw new Exception("[MWA] SignMessage: signed payloads were not populated");
+            }
             _authToken = authorization.AuthToken;
+            if (_walletOptions.keepConnectionAlive)
+            {
+                PlayerPrefs.SetString("authToken", _authToken);
+                PlayerPrefs.Save();
+            }
             return signedMessages.SignedPayloadsBytes[0];
         }