public async Task <IdentityAccount> GetAccount()
    {
        try
        {
            ScatterSharp.Core.Api.Network network = new ScatterSharp.Core.Api.Network()
            {
                blockchain = ScatterConstants.Blockchains.EOSIO,
                host       = "jungle3.cryptolions.io",
                port       = 443,
                chainId    = "2a02a0053e5a8cf73a56ba0fda11e4d92e0238a4a2aa74fccf46d5a910746840"
            };

            var fileStorage = new FileStorageProvider(Application.persistentDataPath + "/scatterapp.dat");
            using (var scatter = new Scatter(new ScatterConfigurator()
            {
                AppName = "UNITY-PC-SCATTER",
                Network = network,
                StorageProvider = fileStorage
            }, this))
            {
                await scatter.Connect();

                await scatter.GetIdentity(new IdentityRequiredFields()
                {
                    accounts = new List <ScatterSharp.Core.Api.Network>()
                    {
                        network
                    },
                    location = new List <LocationFields>(),
                    personal = new List <PersonalFields>()
                });

                var eos = new Eos(new EosSharp.Core.EosConfigurator()
                {
                    ChainId      = network.chainId,
                    HttpEndpoint = network.GetHttpEndpoint(),
                    SignProvider = new ScatterSignatureProvider(scatter)
                });

                var account = scatter.Identity.accounts.First();

                return(account);
            }
        }
        catch (ApiErrorException ex)
        {
            print(JsonConvert.SerializeObject(ex.error));
            return(null);
        }
        catch (ApiException ex)
        {
            print(ex.Content);
            return(null);
        }
        catch (Exception ex)
        {
            print(JsonConvert.SerializeObject(ex));
            return(null);
        }
    }
Beispiel #2
0
    public async void InitScatter()
    {
        var network = new ScatterSharp.Api.Network()
        {
            Blockchain = Scatter.Blockchains.EOSIO,
            Host       = "api.eossweden.se",
            Port       = 443,
            Protocol   = "https",
            ChainId    = "aca376f206b8fc25a6ed44dbdc66547c36c6c33e3a119ffbeaef943642f0e906"
        };

        var scatter = new Scatter("UnityTestApp", network);

        await scatter.Connect();

        var identity = await scatter.GetIdentity(new ScatterSharp.Api.IdentityRequiredFields()
        {
            Accounts = new List <ScatterSharp.Api.Network>()
            {
                network
            },
            Location = new List <ScatterSharp.Api.LocationFields>(),
            Personal = new List <ScatterSharp.Api.PersonalFields>()
        });

        Debug.Log(identity);

        var eos = scatter.Eos();
    }
        public async Task <string> Authenticate()
        {
            await Scatter.Connect();

            var identity = await GetIdentityFromScatter();

            return(await Scatter.Authenticate(UtilsHelper.RandomNumber()));
        }
        public async Task <string> GetArbitrarySignature()
        {
            await Scatter.Connect();

            var identity = await GetIdentityFromScatter();

            return(await Scatter.GetArbitrarySignature(identity.publicKey, "HELLO WORLD!"));
        }
        public async Task <string> GetEncryptionKey()
        {
            await Scatter.Connect();

            var fromKey = await Scatter.GetPublicKey(ScatterConstants.Blockchains.EOSIO);

            var toKey = await Scatter.GetPublicKey(ScatterConstants.Blockchains.EOSIO);

            var r = new Random();

            return(await Scatter.GetEncryptionKey(fromKey, toKey, (UInt64)r.Next()));
        }
        public async Task AddToken()
        {
            await Scatter.Connect();

            var identity = await GetIdentityFromScatter();

            await Scatter.AddToken(new Token()
            {
                name     = "EOS",
                symbol   = "EOS",
                contract = "eosio.token"
            });
        }
        public async Task <SignaturesResult> RequestSignature()
        {
            await Scatter.Connect();

            var identity = await GetIdentityFromScatter();

            return(await Scatter.RequestSignature(new
            {
                Network,
                blockchain = ScatterConstants.Blockchains.EOSIO,
                requiredFields = new List <object>(),
                //TODO add transaction
                origin = Scatter.GetAppName()
            }));
        }
        public async Task <bool> LinkAccount()
        {
            await Scatter.Connect();

            var identity = await GetIdentityFromScatter();

            var account = identity.accounts.First();

            return(await Scatter.LinkAccount(new LinkAccount()
            {
                publicKey = account.publicKey,
                name = account.name,
                authority = account.authority
            }));
        }
Beispiel #9
0
        public static async void Login()
        {
            mScatter = new Scatter(mScatterTitle, mNetwork);

            try
            {
                await mScatter.Connect();
            }
            catch (WebSocketException ex)
            {
                string errorMsg = "";
                switch (ex.ErrorCode)
                {
                case 10061:
                    errorMsg = "데스크탑 스캐터가 실행중이지 않습니다.";
                    break;

                default:
                    errorMsg = ex.Message;
                    break;
                }
                Form1.tbConsoleQueue.Enqueue(errorMsg);
                Form1.btnLoginQueue.Enqueue(true);
                return;
            }

            var identity = await mScatter.GetIdentity(new ScatterSharp.Api.IdentityRequiredFields()
            {
                Accounts = new List <ScatterSharp.Api.Network>()
                {
                    mNetwork
                },
                Location = new List <ScatterSharp.Api.LocationFields>(),
                Personal = new List <ScatterSharp.Api.PersonalFields>()
            });

            string accountName = identity.Accounts[0].Name;

            Form1.tbConsoleQueue.Enqueue("PvP Poker 서버에 " + accountName + " 계정으로 로그인중입니다.");

            var sendPacket = new LoginReqPacket()
            {
                AccountName = accountName
            };

            mAClient.Send(sendPacket);
        }
        public async Task <bool> SimulateSendSecretMessage()
        {
            await Scatter.Connect();

            var fromKey = await Scatter.GetPublicKey(ScatterConstants.Blockchains.EOSIO);

            var toKey = await Scatter.GetPublicKey(ScatterConstants.Blockchains.EOSIO);

            var r              = new Random();
            var nonce          = (UInt64)r.Next();
            var text           = "Hello crypto secret message!";
            var encryptionKeyA = await Scatter.GetEncryptionKey(fromKey, toKey, nonce);

            var encryptionKeyABytes = UtilsHelper.HexStringToByteArray(encryptionKeyA);

            Console.WriteLine("FromKey:    {0}", fromKey);
            Console.WriteLine("ToKey:      {0}", toKey);
            Console.WriteLine("Original:   {0}", text);

            var encrypted = CryptoHelper.AesEncrypt(encryptionKeyABytes, text);

            Console.WriteLine("Encrypted:  {0}", Encoding.UTF8.GetString(encrypted));

            //...Send over the wire...

            var encryptionKeyB = await Scatter.GetEncryptionKey(toKey, fromKey, nonce);

            var encryptionKeyBBytes = UtilsHelper.HexStringToByteArray(encryptionKeyB);

            Console.WriteLine("A_PVT_KEY + B_PUB_KEY:    {0}", encryptionKeyA);
            Console.WriteLine("B_PVT_KEY + A_PUB_KEY:    {0}", encryptionKeyB);

            var roundtrip = CryptoHelper.AesDecrypt(encryptionKeyBBytes, encrypted);

            Console.WriteLine("Round Trip: {0}", roundtrip);

            return(encryptionKeyA == encryptionKeyB);
        }
        public async Task OneWayEncryptDecrypt()
        {
            await Scatter.Connect();

            var fromKey = await Scatter.GetPublicKey(ScatterConstants.Blockchains.EOSIO);

            var toKey = await Scatter.GetPublicKey(ScatterConstants.Blockchains.EOSIO);

            var r             = new Random();
            var encryptionKey = await Scatter.GetEncryptionKey(fromKey, toKey, (UInt64)r.Next());

            var encryptionKeyBytes = UtilsHelper.HexStringToByteArray(encryptionKey);

            string text      = "Hello crypto secret message!";
            var    encrypted = CryptoHelper.AesEncrypt(encryptionKeyBytes, text);
            var    roundtrip = CryptoHelper.AesDecrypt(encryptionKeyBytes, encrypted);

            Console.WriteLine("FromKey:    {0}", fromKey);
            Console.WriteLine("ToKey:      {0}", toKey);
            Console.WriteLine("Original:   {0}", text);
            Console.WriteLine("Encrypted:  {0}", Encoding.UTF8.GetString(encrypted));
            Console.WriteLine("Round Trip: {0}", roundtrip);
        }
Beispiel #12
0
    public async void PushTransaction()
    {
        try
        {
            var network = new ScatterSharp.Api.Network()
            {
                Blockchain = Scatter.Blockchains.EOSIO,
                Host       = "eos.greymass.com",
                Port       = 443,
                Protocol   = "https",
                ChainId    = "aca376f206b8fc25a6ed44dbdc66547c36c6c33e3a119ffbeaef943642f0e906"
            };

            var fileStorage = new FileStorageProvider(Application.persistentDataPath + "/scatterapp.dat");

            using (var scatter = new Scatter("dicePoker", network, fileStorage))
            {
                await scatter.Connect();

                await scatter.GetIdentity(new ScatterSharp.Api.IdentityRequiredFields()
                {
                    Accounts = new List <ScatterSharp.Api.Network>()
                    {
                        network
                    },
                    Location = new List <ScatterSharp.Api.LocationFields>(),
                    Personal = new List <ScatterSharp.Api.PersonalFields>()
                });

                print(scatter.GetVersion());

                var eos = scatter.Eos();

                var account = scatter.Identity.Accounts.First();

                var result = await eos.CreateTransaction(new Transaction()
                {
                    Actions = new List <EosSharp.Api.v1.Action>()
                    {
                        new EosSharp.Api.v1.Action()
                        {
                            Account       = "eosio.token",
                            Authorization = new List <PermissionLevel>()
                            {
                                new PermissionLevel()
                                {
                                    Actor = account.Name, Permission = account.Authority
                                }
                            },
                            Name = "transfer",
                            Data = new { from = account.Name, to = "eosvegasjack", quantity = "0.0001 EOS", memo = "Unity 3D test from blockfish!" }
                        }
                    }
                });

                print(result);
            }
        }

        catch (Exception ex)
        {
            print(JsonConvert.SerializeObject(ex));
        }
    }
        public async Task <byte[]> GetAvatar()
        {
            await Scatter.Connect();

            return(await Scatter.GetAvatar());
        }
    public async void PushTransaction()
    {
        try
        {
            ScatterSharp.Core.Api.Network network = new ScatterSharp.Core.Api.Network()
            {
                blockchain = ScatterConstants.Blockchains.EOSIO,
                host       = "jungle3.cryptolions.io",
                port       = 443,
                chainId    = "2a02a0053e5a8cf73a56ba0fda11e4d92e0238a4a2aa74fccf46d5a910746840"
            };

            var fileStorage = new FileStorageProvider(Application.persistentDataPath + "/scatterapp.dat");
            using (var scatter = new Scatter(new ScatterConfigurator()
            {
                AppName = "UNITY-PC-SCATTER",
                Network = network,
                StorageProvider = fileStorage
            }, this))
            {
                await scatter.Connect();

                await scatter.GetIdentity(new IdentityRequiredFields()
                {
                    accounts = new List <ScatterSharp.Core.Api.Network>()
                    {
                        network
                    },
                    location = new List <LocationFields>(),
                    personal = new List <PersonalFields>()
                });

                var eos = new Eos(new EosSharp.Core.EosConfigurator()
                {
                    ChainId      = network.chainId,
                    HttpEndpoint = network.GetHttpEndpoint(),
                    SignProvider = new ScatterSignatureProvider(scatter)
                });

                var account = scatter.Identity.accounts.First();

                var result = await eos.CreateTransaction(new EosSharp.Core.Api.v1.Transaction()
                {
                    actions = new List <EosSharp.Core.Api.v1.Action>()
                    {
                        new EosSharp.Core.Api.v1.Action()
                        {
                            account       = "eosio.token",
                            authorization = new List <PermissionLevel>()
                            {
                                new PermissionLevel()
                                {
                                    actor = account.name, permission = account.authority
                                }
                            },
                            name = "transfer",
                            data = new Dictionary <string, object>()
                            {
                                { "from", account.name },
                                { "to", "eosio" },
                                { "quantity", "0.0001 EOS" },
                                { "memo", "Unity3D WEBGL hello crypto world!" }
                            }
                        }
                    }
                });

                print(result);
            }
        }
        catch (ApiErrorException ex)
        {
            print(JsonConvert.SerializeObject(ex.error));
        }
        catch (ApiException ex)
        {
            print(ex.Content);
        }
        catch (Exception ex)
        {
            print(JsonConvert.SerializeObject(ex));
        }
    }
        public async Task <string> GetPublicKey()
        {
            await Scatter.Connect();

            return(await Scatter.GetPublicKey(ScatterConstants.Blockchains.EOSIO));
        }
        public async Task <bool> HasAccountFor()
        {
            await Scatter.Connect();

            return(await Scatter.HasAccountFor());
        }
        public async Task <bool> SuggestNetwork()
        {
            await Scatter.Connect();

            return(await Scatter.SuggestNetwork());
        }
        public async Task <bool> ForgetIdentity()
        {
            await Scatter.Connect();

            return(await Scatter.ForgetIdentity());
        }
        public async Task <Identity> GetIdentityFromPermissions()
        {
            await Scatter.Connect();

            return(await Scatter.GetIdentityFromPermissions());
        }
        public async Task <Identity> GetIdentity()
        {
            await Scatter.Connect();

            return(await GetIdentityFromScatter());
        }
        public async Task <string> GetVersion()
        {
            await Scatter.Connect();

            return(await Scatter.GetVersion());
        }
        public async Task <Identity> LoginAll()
        {
            await Scatter.Connect();

            return(await Scatter.LoginAll());
        }
    public async void PushTransaction()
    {
        try
        {
            ScatterSharp.Core.Api.Network network = new ScatterSharp.Core.Api.Network()
            {
                blockchain = ScatterConstants.Blockchains.EOSIO,
                host       = "nodes.eos42.io",
                port       = 443,
                chainId    = "aca376f206b8fc25a6ed44dbdc66547c36c6c33e3a119ffbeaef943642f0e906"
            };

            var fileStorage = new FileStorageProvider(Application.persistentDataPath + "/scatterapp.dat");

            using (var scatter = new Scatter(new ScatterConfigurator()
            {
                AppName = "UNITY-WEBGL-SCATTER",
                Network = network,
                StorageProvider = fileStorage
            }, this))
            {
                await scatter.Connect();

                await scatter.GetIdentity(new IdentityRequiredFields()
                {
                    accounts = new List <ScatterSharp.Core.Api.Network>()
                    {
                        network
                    },
                    location = new List <LocationFields>(),
                    personal = new List <PersonalFields>()
                });

                var eos = new Eos(new EosSharp.Core.EosConfigurator()
                {
                    ChainId      = network.chainId,
                    HttpEndpoint = network.GetHttpEndpoint(),
                    SignProvider = new ScatterSignatureProvider(scatter)
                });

                var account = scatter.Identity.accounts.First();

                var result = await eos.CreateTransaction(new EosSharp.Core.Api.v1.Transaction()
                {
                    actions = new List <EosSharp.Core.Api.v1.Action>()
                    {
                        new EosSharp.Core.Api.v1.Action()
                        {
                            account       = "eosio.token",
                            authorization = new List <PermissionLevel>()
                            {
                                new PermissionLevel()
                                {
                                    actor = account.name, permission = account.authority
                                }
                            },
                            name = "transfer",
                            data = new Dictionary <string, object>()
                            {
                                { "from", account.name },
                                { "to", "eosio" },
                                { "quantity", "0.0001 EOS" },
                                { "memo", "Unity3D WEBGL hello crypto world!" }
                            }
                        }
                    }
                });

                print(result);
            }
        }
        catch (Exception ex)
        {
            print(JsonConvert.SerializeObject(ex));
        }
    }
        //TODO parse "error": "to account does not exist"

        public async Task <object> RequestTransfer()
        {
            await Scatter.Connect();

            return(await Scatter.RequestTransfer("tester112345", "tester212345", "0.0001 EOS"));
        }
Beispiel #25
0
    public async void PushTransaction()
    {
        try
        {
            var network = new ScatterSharp.Api.Network()
            {
                Blockchain = Scatter.Blockchains.EOSIO,
                Host       = "api.jungle.alohaeos.com",
                Port       = 443,
                Protocol   = "https",
                ChainId    = "038f4b0fc8ff18a4f0842a8f0564611f6e96e8535901dd45e43ac8691a1c4dca"
            };

            var fileStorage = new FileStorageProvider(Application.persistentDataPath + "/scatterapp.dat");

            using (var scatter = new Scatter("UNITY-SCATTER-JUNGLE", network, fileStorage))
            {
                await scatter.Connect();

                await scatter.GetIdentity(new ScatterSharp.Api.IdentityRequiredFields()
                {
                    Accounts = new List <ScatterSharp.Api.Network>()
                    {
                        network
                    },
                    Location = new List <ScatterSharp.Api.LocationFields>(),
                    Personal = new List <ScatterSharp.Api.PersonalFields>()
                });

                var eos = scatter.Eos();

                var account = scatter.Identity.Accounts.First();

                var result = await eos.CreateTransaction(new Transaction()
                {
                    Actions = new List <EosSharp.Api.v1.Action>()
                    {
                        new EosSharp.Api.v1.Action()
                        {
                            Account       = "eosio.token",
                            Authorization = new List <PermissionLevel>()
                            {
                                new PermissionLevel()
                                {
                                    Actor = account.Name, Permission = account.Authority
                                }
                            },
                            Name = "transfer",
                            Data = new { from = account.Name, to = "eosio", quantity = "0.0001 EOS", memo = "Unity 3D hello crypto world!" }
                        }
                    }
                });

                print(result);
            }
        }
        catch (Exception ex)
        {
            print(JsonConvert.SerializeObject(ex));
        }
    }
 public async Task Connect()
 {
     await Scatter.Connect();
 }