Hyperplay Integration (#88)

Author: 0xFirekeeper

Assets/Thirdweb/Core/Scripts/Hyperplay.meta

@@ -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/Hyperplay.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/Hyperplay.cs.meta

@@ -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.meta

@@ -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);
+        }
+    }
+}