Ejemplo n.º 1
0
        public ExchangeService(ILoggerFactory loggerFactory,
                               ApplicationDbContext db,
                               IConfiguration configuration,
                               IRateCache rateCache,
                               IMemoryCache cache,
                               ICryptoProviderService cryptoProviderService,
                               IGraftWalletService wallet)
        {
            _settings = configuration
                        .GetSection("PaymentService")
                        .Get <PaymentServiceConfiguration>();

            _logger                = loggerFactory.CreateLogger(nameof(ExchangeService));
            _db                    = db;
            _rateCache             = rateCache;
            _cache                 = cache;
            _cryptoProviderService = cryptoProviderService;
            _wallet                = wallet;
        }
Ejemplo n.º 2
0
        internal static void Recalc(Exchange exchange, PaymentServiceConfiguration settings)
        {
            decimal sellRate    = exchange.SellToUsdRate;
            decimal graftRate   = exchange.GraftToUsdRate;
            decimal sellAmount  = 0;
            decimal graftAmount = 0;
            decimal buyerAmount = 0;
            decimal feeAmount   = 0;
            decimal fee         = settings.ExchangeBrokerFee;

            sellAmount  = exchange.ReceivedAmount;
            graftAmount = sellAmount * sellRate / graftRate;
            feeAmount   = graftAmount * fee;
            buyerAmount = graftAmount - feeAmount;

            exchange.SellAmount        = sellAmount;
            exchange.BuyAmount         = buyerAmount;
            exchange.ExchangeBrokerFee = feeAmount;

            exchange.Log($"Recalcalated amounts: {exchange.SellAmount} {exchange.SellCurrency} to {exchange.BuyAmount} {exchange.BuyCurrency}");
        }
Ejemplo n.º 3
0
        internal static async Task <Exchange> Create(BrokerExchangeParams model,
                                                     IRateCache rateCache, PaymentServiceConfiguration settings)
        {
            var log = new List <EventItem>
            {
                new EventItem($"Started exchange calculation")
            };

            log.Add(new EventItem($"Requesting {model.SellCurrency} rate..."));
            decimal sellRate = await rateCache.GetRateToUsd(model.SellCurrency);

            log.Add(new EventItem($"Received {model.SellCurrency} rate: {sellRate} USD"));

            log.Add(new EventItem($"Requesting GRFT rate..."));
            decimal graftRate = await rateCache.GetRateToUsd("GRFT");

            log.Add(new EventItem($"Received GRFT rate: {graftRate} USD"));

            decimal sellAmount  = 0;
            decimal graftAmount = 0;
            decimal buyerAmount = 0;
            decimal feeAmount   = 0;
            decimal fee         = settings.ExchangeBrokerFee;

            if (!string.IsNullOrWhiteSpace(model.FiatCurrency))
            {
                if (model.SellFiatAmount > 0)
                {
                    sellAmount  = model.SellFiatAmount / sellRate;
                    graftAmount = model.SellFiatAmount / graftRate;
                    feeAmount   = graftAmount * fee;
                    buyerAmount = graftAmount - feeAmount;
                }
                else
                {
                    buyerAmount = model.BuyFiatAmount / graftRate;
                    graftAmount = buyerAmount / (1 - fee);
                    feeAmount   = graftAmount - buyerAmount;
                    sellAmount  = graftAmount * graftRate / sellRate;
                }
            }
            else
            {
                if (model.SellAmount > 0)
                {
                    sellAmount  = model.SellAmount;
                    graftAmount = sellAmount * sellRate / graftRate;
                    feeAmount   = graftAmount * fee;
                    buyerAmount = graftAmount - feeAmount;
                }
                else
                {
                    buyerAmount = model.BuyAmount;
                    graftAmount = buyerAmount / (1 - fee);
                    feeAmount   = graftAmount - buyerAmount;
                    sellAmount  = graftAmount * graftRate / sellRate;
                }
            }

            var exchange = new Exchange
            {
                ExchangeId = Guid.NewGuid().ToString(),
                CreatedAt  = DateTime.UtcNow,
                Status     = PaymentStatus.Waiting,

                SellAmount   = sellAmount,
                SellCurrency = model.SellCurrency,

                BuyAmount   = buyerAmount,
                BuyCurrency = model.BuyCurrency,

                SellToUsdRate  = sellRate,
                GraftToUsdRate = graftRate,

                ExchangeBrokerFee = feeAmount,

                BuyerWallet = model.WalletAddress,

                BuyerTransactionStatus = GraftTransactionStatus.New
            };

            exchange.ProcessingEvents = log;

            log.Add(new EventItem($"Created exchange: {exchange.SellAmount} {exchange.SellCurrency} to {exchange.BuyAmount} {exchange.BuyCurrency}"));
            log.Add(new EventItem($"Exchange Broker fee of {fee*100}% is {exchange.ExchangeBrokerFee} GRFT"));

            return(exchange);
        }