Exemple #1
0
        private void AddTokens()
        {
            var dai = new Erc20TokenModel("DAI", this.ethereumService);

            dai.QueryProperties();
            Tokens.Add(dai);

            var bnb = new Erc20TokenModel("BNB", this.ethereumService);

            bnb.QueryProperties();
            Tokens.Add(bnb);

            var wbtc = new Erc20TokenModel("WBTC", this.ethereumService);

            wbtc.QueryProperties();
            Tokens.Add(wbtc);

            var usdt = new Erc20TokenModel("USDT", this.ethereumService);

            usdt.QueryProperties();
            Tokens.Add(usdt);

            //var usdc = new Erc20TokenModel("USDC", this.ethereumService);

            //usdc.QueryProperties();
            //Tokens.Add(usdc);

            var tusd = new Erc20TokenModel("TUSD", this.ethereumService);

            tusd.QueryProperties();
            Tokens.Add(tusd);

            var link = new Erc20TokenModel("LINK", this.ethereumService);

            link.QueryProperties();
            Tokens.Add(link);

            var mkr = new Erc20TokenModel("MKR", this.ethereumService);

            mkr.QueryProperties();
            Tokens.Add(mkr);

            var ht = new Erc20TokenModel("HT", this.ethereumService);

            ht.QueryProperties();
            Tokens.Add(ht);

            //var pax = new Erc20TokenModel("PAX", this.ethereumService);

            //pax.QueryProperties();
            //Tokens.Add(pax);
        }
Exemple #2
0
        private void GetPrice(string ethTokenPair)
        {
            Function getEthToTokenInputPriceFunction = null;

            switch (ethTokenPair)
            {
            case "ETH-DAI":
                getEthToTokenInputPriceFunction = this.uniswapDaiExchContract.GetFunction("getEthToTokenInputPrice");
                break;

            case "ETH-USDC":
                getEthToTokenInputPriceFunction = this.uniswapUsdcExchContract.GetFunction("getEthToTokenInputPrice");
                break;

            case "ETH-TUSD":
                getEthToTokenInputPriceFunction = this.uniswapTusdExchContract.GetFunction("getEthToTokenInputPrice");
                break;

            default:
                var price = new PriceModel
                {
                    Name   = ethTokenPair,
                    Token  = null,
                    Market = "Unsupported",
                    Open   = 0,
                    High   = 0,
                    Low    = 0,
                    Close  = 0,
                    Time   = DateTime.UtcNow
                };

                lock (Prices)
                {
                    if (Prices.Contains(price))
                    {
                        var oldPriceIdx = Prices.IndexOf(price);

                        if (oldPriceIdx > -1)
                        {
                            Prices[oldPriceIdx].Time = DateTime.UtcNow;
                        }
                        else
                        {
                            Prices.Add(price);
                        }
                    }
                    else
                    {
                        Prices.Add(price);
                    }
                }
                return;
            }

            var ethPriceAwaiter = getEthToTokenInputPriceFunction.CallAsync <UInt64>(1).GetAwaiter();

            ethPriceAwaiter.OnCompleted(() =>
            {
                var ethPrice              = ethPriceAwaiter.GetResult();
                var baseTokenName         = ethTokenPair.Split('-')[1];
                Erc20TokenModel baseToken = null;

                foreach (var token in Tokens)
                {
                    if (token.Name == baseTokenName)
                    {
                        baseToken = token;
                        break;
                    }
                }

                if (baseToken == null)
                {
                    baseToken = new Erc20TokenModel(baseTokenName, this.ethereumService);
                    baseToken.QueryProperties();
                    Tokens.Add(baseToken);
                }

                var price = new PriceModel
                {
                    Name   = ethTokenPair,
                    Token  = baseToken,
                    Market = "Uniswap",
                    Open   = ethPrice,
                    High   = ethPrice,
                    Low    = ethPrice,
                    Close  = ethPrice,
                    Time   = DateTime.UtcNow
                };

                lock (Prices)
                {
                    if (Prices.Contains(price))
                    {
                        var oldPriceIdx = Prices.IndexOf(price);

                        if (oldPriceIdx > -1)
                        {
                            Prices[oldPriceIdx].High  = ethPrice > Prices[oldPriceIdx].High ? ethPrice : Prices[oldPriceIdx].High;
                            Prices[oldPriceIdx].Low   = ethPrice < Prices[oldPriceIdx].Low ? ethPrice : Prices[oldPriceIdx].Low;
                            Prices[oldPriceIdx].Close = ethPrice;
                            Prices[oldPriceIdx].Time  = DateTime.UtcNow;
                        }
                        else
                        {
                            Prices.Add(price);
                        }
                    }
                    else
                    {
                        Prices.Add(price);
                    }
                }
            });
        }