Hyperplay Integration

Assets/Thirdweb/Core/Scripts/Hyperplay/Hyperplay.cs

@@ -0,0 +1,77 @@
+using System.Threading.Tasks;
+using Nethereum.JsonRpc.Client.RpcMessages;
+using UnityEngine;
+using UnityEngine.Networking;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Thirdweb.Hyperplay
+{
+    public class Hyperplay
+    {
+        public string[] Accounts { get; private set; }
+        public string ChainId { get; private set; }
+
+        public Hyperplay(string chainId)
+        {
+            ChainId = chainId;
+            Accounts = null;
+        }
+
+        internal async Task Initialize()
+        {
+            Accounts = (await Request(new RpcRequestMessage(-1, "eth_accounts"))).GetResult<string[]>();
+        }
+
+        internal async Task<RpcResponseMessage> Request(RpcRequestMessage message)
+        {
+            HyperplayRequest hyperplayRequest = new HyperplayRequest() { Method = message.Method, Params = message.RawParameters };
+            string jsonString = JsonConvert.SerializeObject(hyperplayRequest);
+            byte[] jsonBytes = System.Text.Encoding.UTF8.GetBytes(jsonString);
+            using (var request = new UnityWebRequest("localhost:9680/rpcRaw", "POST"))
+            {
+                request.uploadHandler = new UploadHandlerRaw(jsonBytes);
+                request.downloadHandler = new DownloadHandlerBuffer();
+                request.SetRequestHeader("Content-Type", "application/json");
+                await request.SendWebRequest();
+                if (request.result != UnityWebRequest.Result.Success)
+                {
+                    Debug.LogError(request.error);
+                    throw new UnityException("RPC request failed: " + request.error);
+                }
+                var hyperplayResult = JsonConvert.DeserializeObject<HyperplayResult>(request.downloadHandler.text);
+                try
+                {
+                    return new RpcResponseMessage(message.Id, JsonConvert.DeserializeObject<JToken>(hyperplayResult.Result.ToString()));
+                }
+                catch
+                {
+                    return new RpcResponseMessage(message.Id, hyperplayResult.Result.ToString());
+                }
+            }
+        }
+    }
+
+    [System.Serializable]
+    public struct HyperplayRequest
+    {
+        [JsonProperty("method")]
+        public string Method { get; set; }
+
+        [JsonProperty("params")]
+        public object Params { get; set; }
+    }
+
+    [System.Serializable]
+    public struct HyperplayResult
+    {
+        [JsonProperty("result")]
+        public object Result { get; set; }
+
+        [JsonProperty("id")]
+        public long Id { get; set; }
+
+        [JsonProperty("jsonrpc")]
+        public string JsonRpc { get; set; }
+    }
+}

Assets/Thirdweb/Core/Scripts/Hyperplay/Nethereum/HyperplayAccount.cs

@@ -0,0 +1,37 @@
+using Nethereum.JsonRpc.Client;
+using Nethereum.RPC.Accounts;
+using Nethereum.RPC.AccountSigning;
+using Nethereum.RPC.NonceServices;
+using Nethereum.RPC.TransactionManagers;
+
+namespace Thirdweb.Hyperplay
+{
+    public class HyperplayAccount : IAccount
+    {
+        private readonly Hyperplay _wallet;
+        private readonly IClient _client;
+
+        public string Address
+        {
+            get { return _wallet.Accounts[0]; }
+        }
+
+        public ITransactionManager TransactionManager { get; }
+        public INonceService NonceService { get; set; }
+        public IAccountSigningService AccountSigningService { get; }
+
+        public IClient Client
+        {
+            get { return _client; }
+        }
+
+        public HyperplayAccount(Hyperplay wallet, IClient client)
+        {
+            _wallet = wallet;
+            _client = client;
+            TransactionManager = new HyperplayTransactionManager(this);
+            NonceService = new InMemoryNonceService(Address, client);
+            AccountSigningService = new AccountSigningService(client);
+        }
+    }
+}

Assets/Thirdweb/Core/Scripts/Hyperplay/Nethereum/HyperplayClient.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Nethereum.JsonRpc.Client;
+using Nethereum.JsonRpc.Client.RpcMessages;
+
+namespace Thirdweb.Hyperplay
+{
+    public class HyperplayClient : ClientBase
+    {
+        private Hyperplay _hyperplay;
+
+        public HyperplayClient(Hyperplay Hyperplay)
+        {
+            this._hyperplay = Hyperplay;
+        }
+
+        private static readonly Random rng = new Random();
+        private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+        public static long GenerateRpcId()
+        {
+            var date = (long)((DateTime.UtcNow - UnixEpoch).TotalMilliseconds) * (10L * 10L * 10L);
+            var extra = (long)Math.Floor(rng.NextDouble() * (10.0 * 10.0 * 10.0));
+            return date + extra;
+        }
+
+        protected override async Task<RpcResponseMessage> SendAsync(RpcRequestMessage message, string route = null)
+        {
+            message.Id = GenerateRpcId();
+            return await _hyperplay.Request(message);
+        }
+
+        protected override Task<RpcResponseMessage[]> SendAsync(RpcRequestMessage[] requests)
+        {
+            return Task.WhenAll(requests.Select(r => SendAsync(r)));
+        }
+    }
+}

Assets/Thirdweb/Core/Scripts/Hyperplay/Nethereum/HyperplayNEthereumExtensions.cs

@@ -0,0 +1,14 @@
+using Nethereum.Web3;
+
+namespace Thirdweb.Hyperplay
+{
+    public static class HyperplayNEthereumExtensions
+    {
+        public static Web3 CreateWeb3(this Hyperplay Hyperplay)
+        {
+            var client = new HyperplayClient(Hyperplay);
+            var account = new HyperplayAccount(Hyperplay, client);
+            return new Web3(account, client);
+        }
+    }
+}

Assets/Thirdweb/Core/Scripts/Hyperplay/Nethereum/HyperplayTransactionManager.cs

@@ -0,0 +1,11 @@
+namespace Thirdweb.Hyperplay
+{
+    public class HyperplayTransactionManager : Nethereum.RPC.TransactionManagers.TransactionManager
+    {
+        public HyperplayTransactionManager(HyperplayAccount account)
+            : base(account.Client)
+        {
+            Account = account;
+        }
+    }
+}

Assets/Thirdweb/Core/Scripts/ThirdwebSession.cs

@@ -76,6 +76,9 @@ public async Task<string> Connect(WalletConnection walletConnection)
                         throw new UnityException("Smart wallet config is required for smart wallet connection method!");
                     ActiveWallet = new ThirdwebSmartWallet(ActiveWallet, Options.smartWalletConfig.Value);
                     break;
+                case WalletProvider.Hyperplay:
+                    ActiveWallet = new ThirdwebHyperplay(ChainId.ToString());
+                    break;
                 default:
                     throw new UnityException("This wallet connection method is not supported on this platform!");
             }

Assets/Thirdweb/Core/Scripts/Wallet.cs

@@ -531,6 +531,7 @@ public enum WalletProvider
         MagicLink,
         LocalWallet,
         SmartWallet,
-        Paper
+        Paper,
+        Hyperplay
     }
 }

Assets/Thirdweb/Core/Scripts/Wallets/ThirdwebHyperplay.cs

@@ -0,0 +1,79 @@
+using System.Threading.Tasks;
+using Nethereum.Web3;
+using Nethereum.Web3.Accounts;
+using Thirdweb.Hyperplay;
+
+namespace Thirdweb.Wallets
+{
+    public class ThirdwebHyperplay : IThirdwebWallet
+    {
+        private Web3 _web3;
+        private WalletProvider _provider;
+        private WalletProvider _signerProvider;
+        private Hyperplay.Hyperplay _hyperPlay;
+
+        public ThirdwebHyperplay(string chainId)
+        {
+            _web3 = null;
+            _provider = WalletProvider.Hyperplay;
+            _signerProvider = WalletProvider.Hyperplay;
+            _hyperPlay = new Hyperplay.Hyperplay(chainId);
+        }
+
+        public async Task<string> Connect(WalletConnection walletConnection, string rpc)
+        {
+            await _hyperPlay.Initialize();
+            _web3 = _hyperPlay.CreateWeb3();
+            return _hyperPlay.Accounts[0];
+        }
+
+        public Task Disconnect()
+        {
+            _web3 = null;
+            return Task.CompletedTask;
+        }
+
+        public Account GetLocalAccount()
+        {
+            return null;
+        }
+
+        public Task<string> GetAddress()
+        {
+            var addy = _hyperPlay.Accounts[0];
+            if (addy != null)
+                addy = addy.ToChecksumAddress();
+            return Task.FromResult(addy);
+        }
+
+        public async Task<string> GetSignerAddress()
+        {
+            return await GetAddress();
+        }
+
+        public WalletProvider GetProvider()
+        {
+            return _provider;
+        }
+
+        public WalletProvider GetSignerProvider()
+        {
+            return _signerProvider;
+        }
+
+        public Task<Web3> GetWeb3()
+        {
+            return Task.FromResult(_web3);
+        }
+
+        public async Task<Web3> GetSignerWeb3()
+        {
+            return await GetWeb3();
+        }
+
+        public Task<bool> IsConnected()
+        {
+            return Task.FromResult(_web3 != null);
+        }
+    }
+}