public bool WriteTransactionOutput(StringBuilder sql)
        {
            if (From == null)
            {
                return(false);
            }

            decimal    totalAmount = 0;
            decimal    singleTx    = 0;
            List <int> recipients  = new List <int>();

            for (int i = 0; i < Transactions.Length; i++)
            {
                if (Transactions[i].Tx != null)
                {
                    totalAmount += Transactions[i].Tx.Amount.Value;
                    recipients.Add(Transactions[i].To.UserId);
                    singleTx = Transactions[i].Tx.Amount.Value;
                }
            }
            TotalAmount     = totalAmount;
            ValidRecipients = recipients.ToArray();
            if (ValidRecipients.Length > 0)
            {
                sql.Append(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), singleTx, '+', nameof(UserWallet.UserId), ValidRecipients));
                sql.Append(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), totalAmount, '-', nameof(UserWallet.UserId), From.UserId));
                return(true);
            }
            return(false);
        }
Esempio n. 2
0
        public static async Task <CornTx> DebitWithdrawTx(string cornaddy, string txId, User user, WalletServer server, decimal amount, BitcornContext dbContext, string platform, int emptyUser)
        {
            if (user.UserWallet.Balance >= amount)
            {
                var sql = new StringBuilder();
                sql.Append(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), amount, '-', nameof(UserWallet.UserId), user.UserId));
                sql.Append(TxUtils.ModifyNumber(nameof(WalletServer), nameof(WalletServer.ServerBalance), amount, '-', nameof(WalletServer.Id), server.Id));
                await DbOperations.ExecuteSqlRawAsync(dbContext, sql.ToString());

                var log = new CornTx();
                log.BlockchainTxId = txId;
                log.Amount         = amount;
                log.Timestamp      = DateTime.Now;
                log.TxType         = "$withdraw";
                log.TxGroupId      = Guid.NewGuid().ToString();
                log.Platform       = platform;
                log.ReceiverId     = emptyUser;
                log.SenderId       = user.UserId;
                log.CornAddy       = cornaddy;

                var price = log.UsdtPrice = await ProbitApi.GetCornPriceAsync(dbContext);

                log.TotalUsdtValue = price * amount;
                dbContext.CornTx.Add(log);
                await dbContext.SaveAsync();

                return(log);
            }
            return(null);
        }
Esempio n. 3
0
        public async Task <int> Payout([FromBody] HashSet <string> chatters)
        {
            try
            {
                var grouping = (await _dbContext.JoinUserModels().Where(u => chatters.Contains(u.UserIdentity.TwitchId))
                                .AsNoTracking()
                                .ToArrayAsync()).GroupBy(u => u.SubTier).ToArray();

                decimal       total       = 0;
                int           changedRows = 0;
                StringBuilder sql         = new StringBuilder();

                var pk = nameof(UserWallet.UserId);
                foreach (var group in grouping)
                {
                    decimal payout = 0;
                    var     level  = group.Key;
                    if (level == 0)
                    {
                        continue;
                    }
                    var ids = group.Select(u => u.UserId).ToArray();
                    if (level == 1)
                    {
                        payout = 0.25m;
                    }
                    else if (level == 2)
                    {
                        payout = .5m;
                    }
                    else
                    {
                        payout = 1;
                    }
                    sql.Append(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), payout, '+', pk, ids));
                    sql.Append(TxUtils.ModifyNumber(nameof(UserStat), nameof(UserStat.EarnedIdle), payout, '+', pk, ids));

                    int count = await _dbContext.Database.ExecuteSqlRawAsync(sql.ToString());

                    total       += payout * count;
                    changedRows += count;
                }
                if (changedRows > 0)
                {
                    await _dbContext.Database.ExecuteSqlRawAsync(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), total, '-', pk, BitcornHubPK));
                }
                //this endpoint is called frequently so can use this to check if there are tx's that need to be refunded
                await TxUtils.RefundUnclaimed(_dbContext);

                return(changedRows / 2);
            }
            catch (Exception e)
            {
                await BITCORNLogger.LogError(_dbContext, e);

                throw e;
            }
        }
Esempio n. 4
0
        public static async Task <CornTx> DebitWithdrawTx(string txId, User user, WalletServer server, decimal amount, BitcornContext dbContext, string platform)
        {
            if (user.UserWallet.Balance >= amount)
            {
                var sql = new StringBuilder();
                sql.Append(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), amount, '-', nameof(UserWallet.UserId), user.UserId));
                sql.Append(TxUtils.ModifyNumber(nameof(WalletServer), nameof(WalletServer.ServerBalance), amount, '-', nameof(WalletServer.Id), server.Id));
                await dbContext.Database.ExecuteSqlRawAsync(sql.ToString());

                var log = new CornTx();
                log.BlockchainTxId = txId;
                log.Amount         = amount;
                log.Timestamp      = DateTime.Now;
                log.TxType         = "$withdraw";
                log.TxGroupId      = Guid.NewGuid().ToString();
                log.Platform       = platform;
                log.ReceiverId     = user.UserId;
                dbContext.CornTx.Add(log);
                await dbContext.SaveAsync();

                return(log);
            }
            return(null);
        }
Esempio n. 5
0
        public static async Task <CornTx[]> Deposit(BitcornContext dbContext, WalletDepositRequest request)
        {
            var receipts = new List <CornTx>();

            try
            {
                var server      = dbContext.WalletServer.FirstOrDefault((s) => s.Index == request.Index);
                int newDeposits = 0;

                var sql = new StringBuilder();
                foreach (var payment in request.Payments)
                {
                    decimal amount  = payment.Amount;
                    string  address = payment.Address;
                    string  txid    = payment.TxId;

                    bool isLogged = await dbContext.IsDepositRegistered(txid);

                    if (!isLogged)
                    {
                        newDeposits++;
                        var wallet = await dbContext.WalletByAddress(address);

                        if (wallet != null)
                        {
                            var cornTx = new CornTx();
                            cornTx.Amount         = amount;
                            cornTx.BlockchainTxId = txid;
                            cornTx.ReceiverId     = wallet.UserId;
                            cornTx.SenderId       = null;
                            cornTx.Timestamp      = DateTime.Now;
                            cornTx.TxType         = TransactionType.receive.ToString();
                            cornTx.Platform       = "wallet-server";
                            cornTx.TxGroupId      = Guid.NewGuid().ToString();
                            var deposit = new CornDeposit();
                            deposit.TxId   = txid;
                            deposit.UserId = wallet.UserId;

                            sql.Append(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), amount, '+', nameof(UserWallet.UserId), wallet.UserId));
                            sql.Append(TxUtils.ModifyNumber(nameof(WalletServer), nameof(WalletServer.ServerBalance), amount, '+', nameof(WalletServer.Id), server.Id));

                            dbContext.CornTx.Add(cornTx);
                            dbContext.CornDeposit.Add(deposit);
                            receipts.Add(cornTx);
                        }
                    }
                }

                if (newDeposits > 0)
                {
                    server.LastBalanceUpdateBlock = request.Block;
                    int count = await dbContext.Database.ExecuteSqlRawAsync(sql.ToString());

                    await dbContext.SaveAsync();
                }
            }
            catch (Exception e)
            {
                await BITCORNLogger.LogError(dbContext, e);
            }
            return(receipts.ToArray());
        }
Esempio n. 6
0
        public async Task <ActionResult <TxReceipt[]> > Tipcorn([FromBody] TipRequest tipRequest)
        {
            if (tipRequest == null)
            {
                throw new ArgumentNullException();
            }
            if (tipRequest.From == null)
            {
                throw new ArgumentNullException();
            }
            if (tipRequest.To == null)
            {
                throw new ArgumentNullException();
            }
            if (tipRequest.To == tipRequest.From)
            {
                return(StatusCode((int)HttpStatusCode.BadRequest));
            }
            if (tipRequest.Amount <= 0)
            {
                return(StatusCode((int)HttpStatusCode.BadRequest));
            }

            try
            {
                var processInfo = await TxUtils.ProcessRequest(tipRequest, _dbContext);

                var transactions = processInfo.Transactions;
                if (transactions != null && transactions.Length > 0)
                {
                    StringBuilder sql = new StringBuilder();
                    if (processInfo.WriteTransactionOutput(sql))
                    {
                        var receipt = transactions[0];
                        if (receipt.Tx != null)
                        {
                            var    to        = receipt.To.User.UserStat;
                            var    from      = receipt.From.User.UserStat;
                            var    amount    = tipRequest.Amount;
                            string table     = nameof(UserStat);
                            var    pk        = nameof(UserStat.UserId);
                            var    fromStats = new List <ColumnValuePair>();

                            fromStats.Add(new ColumnValuePair(nameof(UserStat.Tip), 1));
                            fromStats.Add(new ColumnValuePair(nameof(UserStat.TipTotal), amount));

                            sql.Append(TxUtils.ModifyNumbers(table, fromStats, '+', pk, from.UserId));

                            var toStats = new List <ColumnValuePair>();
                            toStats.Add(new ColumnValuePair(nameof(UserStat.Tipped), 1));
                            toStats.Add(new ColumnValuePair(nameof(UserStat.TippedTotal), amount));

                            sql.Append(TxUtils.ModifyNumbers(table, toStats, '+', pk, to.UserId));

                            sql.Append(TxUtils.UpdateNumberIfTop(table, nameof(UserStat.TopTip), amount, pk, from.UserId));
                            sql.Append(TxUtils.UpdateNumberIfTop(table, nameof(UserStat.TopTipped), amount, pk, to.UserId));

                            await _dbContext.Database.ExecuteSqlRawAsync(sql.ToString());

                            await _dbContext.SaveAsync(IsolationLevel.RepeatableRead);
                        }
                    }
                    else
                    {
                        if (processInfo.From != null && !processInfo.From.IsBanned && processInfo.Transactions[0].To == null)
                        {
                            if (processInfo.From.UserWallet.Balance >= tipRequest.Amount)
                            {
                                var unclaimed = new UnclaimedTx();
                                unclaimed.TxType             = ((ITxRequest)tipRequest).TxType;
                                unclaimed.Platform           = tipRequest.Platform;
                                unclaimed.ReceiverPlatformId = BitcornUtils.GetPlatformId(tipRequest.To).Id;
                                unclaimed.Amount             = tipRequest.Amount;
                                unclaimed.Timestamp          = DateTime.Now;
                                unclaimed.SenderUserId       = processInfo.From.UserId;
                                unclaimed.Expiration         = DateTime.Now.AddMinutes(TimeToClaimTipMinutes);
                                unclaimed.Claimed            = false;
                                unclaimed.Refunded           = false;

                                _dbContext.UnclaimedTx.Add(unclaimed);
                                await _dbContext.Database.ExecuteSqlRawAsync(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), tipRequest.Amount, '-', nameof(UserWallet.UserId), processInfo.From.UserId));

                                await _dbContext.SaveAsync();
                            }
                        }
                    }
                    await TxUtils.AppendTxs(transactions, _dbContext, tipRequest.Columns);
                }
                return(transactions);
            }
            catch (Exception e)
            {
                await BITCORNLogger.LogError(_dbContext, e);

                throw e;
            }
        }