public async Task <IActionResult> BetAsync([FromBody] BetRequest request) { Logger.LogDebug(nameof(BetAsync)); // Validate model if (!ModelState.IsValid) { return(BadRequest(ModelState)); } // Get Player if exists var player = await _playerRepository.GetAsync(request.PlayerId).ConfigureAwait(false); // Check Player's Balance if (player.Balance - request.Bet < 0) { return(BadRequest(new BadRequestError($"The Player MAX. Bet Amout is {player.Balance} EUR"))); } // Create new transaction var transaction = new Transaction { PlayerId = player.PlayerId, Bet = request.Bet }; // Persist Transaction await _transactionRepository.AddAsync(transaction).ConfigureAwait(false); // Re-read Player player = await _playerRepository.GetAsync(request.PlayerId).ConfigureAwait(false); return(Ok(player)); }
private async Task <SubmitTransactionResponse> Deposit(Transaction tran, Client client) { client.CurrentAmount += tran.Amount; _clientRepository.Update(client); await _transactionRepository.AddAsync(tran); return(new SubmitTransactionResponse(true, "Deposit completed")); }
public async Task CanAdd() { _logger.LogInformation("CanAdd"); var transaction = new Transaction { Bet = 100 }; var newTransaction = await _transactionRepository.AddAsync(transaction).ConfigureAwait(false); Assert.True(newTransaction.Bet == 100); }
public async Task <Transaction> CreateTransactionAsync(TransactionViewModel model) { var transaction = ModelConverter.ConvertViewToData(model); var addedTransaction = await _transactionRepository.AddAsync(transaction); return(addedTransaction); }
public async Task <Transaction> Save(string clientID, string cpf, string accountID, string locationID, int operationType, int eventType, decimal value) { try { Transaction transaction = new Transaction { ClientID = clientID, CPF = cpf, AccountID = accountID, LocationID = locationID, OperationType = (OperationType)operationType, EventType = (EventType)eventType, Value = value }; transaction.Hash = CalculateHash(transaction); await _repository.AddAsync(transaction); await _repository.SaveAsync(); return(transaction); } catch (Exception ex) { throw ex; } }
public async Task CreateTransactionAsync(string payeeEmail, CreateTransactionDto createTransactionDto) { var payee = await _userRepository.GetByEmailAsync(payeeEmail); var recipient = await _userRepository.GetByNameAsync(createTransactionDto.Recipient); ValidateCreation(payee, recipient, createTransactionDto.Amount, createTransactionDto.Recipient); payee.Balance -= createTransactionDto.Amount; recipient.Balance += createTransactionDto.Amount; var transaction = new PwTransaction { Payee = payee, Recipient = recipient, ResultingPayeeBalance = payee.Balance, ResultingRecipientBalance = recipient.Balance, Amount = createTransactionDto.Amount, TransactionDateTime = DateTime.Now }; await _transactionRepository.AddAsync(transaction); await _balanceHubContext.Clients.Group(recipient.Email).UpdateBalance(recipient.Balance); }
private async Task ProcessAsync(EShopType shopType) { var bufferedData = await _bufferService.GetBufferAsync(shopType); await _bufferService.ClearBufferAsync(shopType); if (bufferedData.Count == 0) { return; } var transaction = await _transactionFactory.CreateAsync(bufferedData[0].ClientCity, bufferedData[0].TransactionDateTime, bufferedData[0].PaymentType, bufferedData[0].ClientPostCode); var shop = await _shopFactory.CreateAsync(bufferedData[0].ShopName, bufferedData[0].ShopType, bufferedData[0].ShopPostCode, bufferedData[0].ShopCity); shop.Transactions.Add(transaction); transaction.Shop = shop; foreach (var rawData in bufferedData) { var product = await _productFactory.CreateAsync(rawData.Price, rawData.Product, rawData.Quantity); var transactionProduct = await _transactionProductFactory.CreateAsync(product, transaction); transaction.TransactionProducts.Add(transactionProduct); product.TransactionProducts.Add(transactionProduct); await _productRepository.AddAsync(product); await _transactionProductRepository.AddAsync(transactionProduct); } await _transactionRepository.AddAsync(transaction); await _shopRepository.AddAsync(shop); await _unitOfWork.SaveAsync(); }
public async Task AddAsync(BillPaymentAddModel model) { if (model.PaymentType == Constants.TransactionType.BillPayment) { var billSummary = await _billRepository.GetSummaryAsunc(model.BillId); var vendorPaymentInfo = await _vendorRepository.GetPaymentInfoAsync(billSummary.VendorId); var billPayment = BillPaymentFactory.Create(model, vendorPaymentInfo.AccountNumber, billSummary.TotalAmount, _userId); await _billPaymentRepository.AddAsync(billPayment); await _billRepository.UpdateStatusAsync(model.BillId, Constants.BillStatus.Paid); //For Transaction Update await _transactionRepository.SetTransactionAccountIdForBill(model.BillId, model.BankAccountId, model.PaymentDate, model.Description); await _unitOfWork.SaveChangesAsync(); } else if (model.PaymentType == Constants.TransactionType.VendorAdvancePayment) { var transaction = TransactionFactory.CreateByVendorAdvancePayment(model, model.BankAccountId, model.Amount, 0, true); await _transactionRepository.AddAsync(transaction); var transactionForDebit = TransactionFactory.CreateByVendorAdvancePayment(model, model.DebitBankAccountId, 0, model.Amount, false); await _transactionRepository.AddAsync(transactionForDebit); await _unitOfWork.SaveChangesAsync(); } else if (model.PaymentType == Constants.TransactionType.AccountExpence) { var transactionforCredit = TransactionFactory.CreateByTaxPaymentByVendor(model, model.BankAccountId, model.Amount, 0, true); await _transactionRepository.AddAsync(transactionforCredit); var transactionforDebit = TransactionFactory.CreateByTaxPaymentByVendor(model, model.DebitBankAccountId, 0, model.Amount, false); await _transactionRepository.AddAsync(transactionforDebit); await _unitOfWork.SaveChangesAsync(); } }
public async Task AddAsync(InvoicePaymentAddModel model) { if (model.PaymentType == Constants.TransactionType.InvoicePayment) { var invoiceSummary = await _invoiceRepository.GetSummaryAsunc(model.InvoiceId); var customerPaymentInfo = await _customerRepository.GetPaymentInfoAsync(invoiceSummary.CustomerId); var invoicePayment = InvoicePaymentFactory.Create(model, customerPaymentInfo.AccountNumber, invoiceSummary.TotalAmount, _userId); await _invoicePaymentRepository.AddAsync(invoicePayment); await _invoiceRepository.UpdateStatusAsync(model.InvoiceId, Constants.InvoiceStatus.Paid); //For Transaction Update await _transactionRepository.SetTransactionAccountIdForInvoice(model.InvoiceId, model.BankAccountId, model.PaymentDate, model.Description); await _unitOfWork.SaveChangesAsync(); } else if (model.PaymentType == Constants.TransactionType.CustomerAdvancePayment) { var transaction = TransactionFactory.CreateByCustomerAdvancePayment(model, model.BankAccountId, 0, model.Amount, true); await _transactionRepository.AddAsync(transaction); var transactionForCredit = TransactionFactory.CreateByCustomerAdvancePayment(model, model.CreditBankAccountId, model.Amount, 0, false); await _transactionRepository.AddAsync(transactionForCredit); await _unitOfWork.SaveChangesAsync(); } else if (model.PaymentType == Constants.TransactionType.AccountIncome) { var transactionforCredit = TransactionFactory.CreateByTaxPaymentByCustomer(model, model.CreditBankAccountId, model.Amount, 0, false); await _transactionRepository.AddAsync(transactionforCredit); var transactionforDebit = TransactionFactory.CreateByTaxPaymentByCustomer(model, model.BankAccountId, 0, model.Amount, true); await _transactionRepository.AddAsync(transactionforDebit); await _unitOfWork.SaveChangesAsync(); } }
public async Task AddAsync(TransactionModel transaction) { TransactionModel newTransaction = await _transactionRepository.AddAsync(transaction); await _messageSession.Publish <ITransactionRequestAdded>(message => { message.TransactionId = newTransaction.Id; message.Amount = newTransaction.Amount; message.SrcAccountId = newTransaction.SrcAccountId; message.DestAccountId = newTransaction.DestAccountId; message.OperationTime = newTransaction.Date; }); }
public async Task <ActionResult> CreateTransaction([FromBody] SaveTransactionResource newTransaction) { var transactionInDb = newTransaction.ToData(); transactionInDb.UserName = User.Identity.Name; transactionInDb.TimeStamp = DateTime.Now; await _transactionRepository.AddAsync(transactionInDb); await _unitOfWork.CompleteAsync(); return(Ok(KidResource.FromData(await _kidRepository.GetKidAsync(newTransaction.KidId, includeRelated: true), includeRelated: true))); }
public async Task <SaveTransactionResponse> AddAsync(WalletTransaction walletTransaction) { if (walletTransaction is null) { throw new ArgumentNullException(nameof(walletTransaction)); } var wallet = await _walletService.GetByGuidAsync(walletTransaction.WalletGuid); if (wallet is null) { return(new SaveTransactionResponse(false, "Transaction for invalid Wallet")); } var transaction = await GetByGuidAsync(walletTransaction.Guid); if (transaction != null) { return(new SaveTransactionResponse(true, "Transaction was already processed.")); } int amountModifier; try { amountModifier = TransactionType.GetAmountModifierByTransactionType(walletTransaction.TransactionType); } catch (ArgumentException ex) { return(new SaveTransactionResponse(false, ex.Message)); } wallet.Balance += walletTransaction.Amount * amountModifier; if (wallet.Balance < 0) { return(new SaveTransactionResponse(false, "Not enough gold.")); } using (var transactionScope = new TransactionScope()) { await _transactionRepository.AddAsync(walletTransaction); await _walletService.UpdateAsync(wallet); transactionScope.Complete(); } return(new SaveTransactionResponse(true)); }
public async Task <TransactionResponse> SaveAsync(Transaction transaction) { try { await _transactionRepository.AddAsync(transaction); await _unitOfWork.CompleteAsync(); return(new TransactionResponse(transaction)); } catch (Exception ex) { return(new TransactionResponse($"An error occurred when saving the transaction: {ex.Message}")); } }
public async Task <Transaction> AddTransactionAsync(string id, string appId, string description, int amount) { var transaction = await _transactions.AddAsync(id, appId, description, amount); using (QueryFactory db = _queryFactory.Invoke()) { // https://github.com/sqlkata/querybuilder/issues/159 await db.StatementAsync("UPDATE users SET Balance = Balance + @Amount WHERE Id = @Id", new { Amount = amount, Id = id }); } return(transaction); }
public async Task <AddTransactionResponse> SaveAsync(TransactionResource resource) { var transaction = _mapper.Map <TransactionResource, Transaction>(resource); try { await _transactionRepository.AddAsync(transaction); await _unitOfWork.CompleteAsync(); return(new AddTransactionResponse(_mapper.Map <Transaction, TransactionResource>(transaction))); } catch (Exception ex) { return(new AddTransactionResponse($"An error occurred when saving the transaction: {ex.Message}")); } }
public async Task <BaseResponse> AddAsync(AddTransactionRequest request, int accountId) { var category = await _categoryRepository.GetAsync(category => category.Id == request.CategoryId && category.AccountId == accountId); if (category == null) { return(new ResultResponse <TransactionDto>("Category is not found")); } if (request.TagId.HasValue) { var tag = await _tagRepository.GetAsync(tag => tag.Id == request.TagId); if (tag == null) { return(new ResultResponse <TransactionDto>("Tag is not found")); } } if (request.SpentById.HasValue) { var spentBy = await _accountUserRepository.GetAsync(accountUser => accountUser.Id == request.SpentById); if (spentBy == null) { return(new ResultResponse <TransactionDto>("Account user is not found")); } } var transaction = _mapper.Map <AddTransactionRequest, Transaction>(request); var loggedUser = await _authenticationService.GetLoggedUserAsync(); var accountUser = await _accountUserRepository.GetAsync(accountUser => accountUser.UserId == loggedUser.User.Id && accountUser.AccountId == category.AccountId); transaction.CreatedBy = accountUser; await _transactionRepository.AddAsync(transaction); await _unitOfWork.SaveChangesAsync(); return(new BaseResponse()); }
public async Task <Response> Handle(Request request, CancellationToken cancellationToken) { Transaction transaction = new( Guid.NewGuid(), TransactionType.Expense, request.Username, request.Amount, request.DateTime, request.CategoryId, request.Description ); var addedTransaction = await _transactionRepository.AddAsync(transaction); await _transactionRepository.SaveChangesAsync(); var response = _mapper.Map <Response>(addedTransaction); return(response); }
public async Task <string> ExecuteAsync( Guid transactionId, string from, string to, BigInteger transactionAmount, BigInteger gasAmount, bool includeFee) { var gasPrice = await _blockchainService.EstimateGasPriceAsync(); var nonce = await _nonceService.GetNextNonceAsync(from); var transactionData = _blockchainService.BuildTransaction ( from: from, to: to, amount: transactionAmount, gasAmount: gasAmount, gasPrice: gasPrice, nonce: nonce ); await _transactionRepository.AddAsync(Transaction.Create ( transactionId: transactionId, from: from, to: to, amount: transactionAmount, gasAmount: gasAmount, gasPrice: gasPrice, includeFee: includeFee, nonce: nonce, data: transactionData )); return(transactionData); }
public async Task <IActionResult> Create(string request) { var transactionDto = _objectJsonConverter.ConvertTransactionJsonDataToObj(request); if (transactionDto != null) { if (transactionDto.TransactionAmount < 0) { _logger.LogInformation($"Error:Transaction with value {transactionDto.TransactionAmount} for account id {transactionDto.AccountId} is less than zero, which is not allowed"); return(Content("Negative amounts cannot be transacted")); } if (!string.IsNullOrEmpty(transactionDto.TransactionCurrency) && transactionDto.TransactionCurrency != "GBP") { transactionDto = await _transactionLogic.SetTransactionAmountToBaseCurrency(transactionDto); } var result = await _transactionLogic.SetAccountBalanceForCreditAndDebit(transactionDto); if (!result) { _logger.LogInformation($"Error:Transaction with value {transactionDto.TransactionAmount} for account id {transactionDto.AccountId} is greater than Available Balance"); return(Content("Transacted Amount is more than the available balance")); } transactionDto.LastUpdated = DateTime.Now; var transactionAdded = await _transactionRepository.AddAsync(_mapper.Map <Transaction>(transactionDto)); if (transactionAdded != null) { _logger.LogInformation($"Info:Transaction with value {transactionDto.TransactionAmount} for account id {transactionDto.AccountId} created successfully"); return(Ok(_mapper.Map <TransactionDto>(transactionAdded))); } return(NotFound()); } return(Content("Transaction is empty")); }
public async Task <TransactionResponse> RegisterTransactionAsync(Transaction transaction, CancellationToken cancellationToken) { _logger.LogDebug("{method} started for transaction {transactionId}.", nameof(RegisterTransactionAsync), transaction.Id); using (await padlock.ReaderLockAsync(cancellationToken).ConfigureAwait(true)) { await EnsurePlayerExistsAsync(transaction.PlayerId, cancellationToken).ConfigureAwait(false); } _logger.LogTrace("{method}: Player {playerId} found.", nameof(RegisterTransactionAsync), transaction.PlayerId); using (await padlock.WriterLockAsync(cancellationToken).ConfigureAwait(true)) { var transactionResponse = await _transactionResponseCache .GetAsync(transaction.Id, cancellationToken) .ConfigureAwait(false); if (transactionResponse is not null) { _logger.LogTrace("{method}: Transaction found in persistent cache. Returning response. {transactionResponse}", nameof(RegisterTransactionAsync), transactionResponse); return(transactionResponse); } try { _logger.LogTrace("{method}: Transaction not found in cache. Returning response.", nameof(RegisterTransactionAsync)); var wallet = await _wallets .GetExistingAsync(transaction.PlayerId, cancellationToken) .ConfigureAwait(false); if (transaction.TransactionType == TransactionType.Stake) { if (transaction.Amount > wallet.Balance) { _logger.LogTrace("{method}: LowBalanceException. Transaction {transactionId} will be as rejected registered.", nameof(RegisterTransactionAsync), transaction.PlayerId); throw new LowBalanceException($"Low balance exception for the Player {transaction.PlayerId}"); } wallet.Balance -= transaction.Amount; } else { wallet.Balance += transaction.Amount; } transactionResponse = new TransactionResponse { TransactionId = transaction.Id, ResponseStatusCode = StatusCodes.Status202Accepted }; await _transactionResponseCache .AddAsync(transactionResponse, cancellationToken) .ConfigureAwait(false); await _transactions.AddAsync(transaction, cancellationToken).ConfigureAwait(false); await _unitOfWork.CommitAsync(cancellationToken).ConfigureAwait(false); _logger.LogTrace("{method}: Transaction {transactionId} registered successfully. The new balance is {balance}.", nameof(RegisterTransactionAsync), transaction.PlayerId, wallet.Balance); } catch (Exception) { transactionResponse = new TransactionResponse { TransactionId = transaction.Id, ResponseStatusCode = StatusCodes.Status403Forbidden }; await _transactionResponseCache .AddAsync(transactionResponse, cancellationToken) .ConfigureAwait(false); await _unitOfWork.CommitAsync(cancellationToken).ConfigureAwait(false); _logger.LogTrace("{method}: Transaction {transactionId} was not executed.", nameof(RegisterTransactionAsync), transaction.PlayerId); } _logger.LogDebug("{method} finished for transaction {transactionId}.", nameof(RegisterTransactionAsync), transaction.Id); return(transactionResponse); } }
public async Task <ProductSelectionResult> Selection(ProductSelection productSelection) { ProductSelectionResult productSelectionResult = new ProductSelectionResult(); try { if (productSelection == null) { productSelectionResult.Code = 1; productSelectionResult.Message = "null parameter"; return(productSelectionResult); } var product = await _productRepository.GetByIdAsync(productSelection.Slot); if (product == null) { productSelectionResult.Slot = productSelection.Slot; productSelectionResult.Code = 1; productSelectionResult.Message = $"Slot: {productSelection.Slot} Message: Slot bulunamadı!"; return(productSelectionResult); } if (!product.IsAvailable) { productSelectionResult.Slot = productSelection.Slot; productSelectionResult.Code = 1; productSelectionResult.Message = "Ürün Bitti!"; return(productSelectionResult); } if (product.NumberOfProducts < productSelection.SelectedPieces) { productSelectionResult.Slot = productSelection.Slot; productSelectionResult.Code = 1; productSelectionResult.Message = $"NumberOfProducts: {product.NumberOfProducts} SelectedPieces: {productSelection.SelectedPieces}"; return(productSelectionResult); } var totalAmount = productSelection.SelectedPieces * product.PriceOfProduct; var campaings = await _campaingRepository.GetAllAsync(); if (campaings != null && campaings.Count > 0) { var campaing = campaings.Where(a => a.Slot == productSelection.Slot).FirstOrDefault(); if (campaing != null) { totalAmount += totalAmount * campaing.DiscountRatio; } } TransactionEntity transactionEntity = new TransactionEntity(); transactionEntity.Slot = productSelection.Slot; transactionEntity.SelectedPieces = productSelection.SelectedPieces; transactionEntity.TransactionAmount = totalAmount; transactionEntity = await _transactionRepository.AddAsync(transactionEntity); productSelectionResult.Slot = productSelection.Slot; productSelectionResult.TransactionId = transactionEntity.Id; productSelectionResult.TotalAmount = totalAmount; productSelectionResult.Code = 0; productSelectionResult.Message = "Başarılı işlem"; } catch (Exception ex) { //logging productSelectionResult.Slot = productSelection.Slot; productSelectionResult.Code = 1; productSelectionResult.Message = "Hata oluştu!"; } return(productSelectionResult); }
public async Task <TransactionResponse> SaveAsync(Guid playerId, IEnumerable <Transaction> transactions) { if (transactions.Count() == 0) { return(new TransactionResponse("Empty transactions")); } var existingPlayer = await _playerRepository.FindByIdAsync(playerId); if (existingPlayer == null) { return(new TransactionResponse("Player not exist")); } try { TransactionStatistics transactionStatistics = new TransactionStatistics(); // traverse through transactions foreach (var transaction in transactions) { try { transaction.PlayerId = playerId; transaction.Player = existingPlayer; var existingTransaction = await _transactionRepository.FindByIdAsync(transaction.TransactionId); if (existingTransaction == null) { // execute transaction await _transactionCommand.ExecuteAction(transaction); // create a new instance of the transaction in the repository transaction.Status = ETransactionStatus.Succeed; await _transactionRepository.AddAsync(transaction); // update successfully processed transaction statistics transactionStatistics.AppliedTransactions.Add(transaction.TransactionId); } else { // duplicated transaction => return cached result if (existingTransaction.Status == ETransactionStatus.Succeed) { transactionStatistics.AppliedTransactions.Add(transaction.TransactionId); } else { transactionStatistics.FailedTransactions.Add(new FailedTransaction { TransactionId = transaction.TransactionId, Message = existingTransaction.Message }); } } } catch (Exception ex) { // update failed transaction statistics transactionStatistics.FailedTransactions.Add(new FailedTransaction { TransactionId = transaction.TransactionId, Message = ex.Message }); transaction.Status = ETransactionStatus.Failed; transaction.Message = ex.Message; await _transactionRepository.AddAsync(transaction); } } // story changes await _unitOfWork.CompleteAsync(); return(new TransactionResponse(transactionStatistics)); } catch (Exception ex) { return(new TransactionResponse($"An error occurred when saving the transaction: {ex.Message}")); } }
public async Task AddAsync(InvoiceAddModel model) { // var items = (await _itemRepository.GetAsync(model.Items)).ToList(); //model.TotalAmount = items.Sum(x => x.Rate); //model.Tax = items.Where(x => x.IsTaxable).Sum(x => x.Rate * x.SalesTax.TaxPercentage / 100); //var customer = await _customerRepository.GetAsync(model.CustomerId); //if (customer.Discount != null) //{ // model.Discount = model.TotalAmount * customer.Discount / 100; // model.TotalAmount = model.TotalAmount - (model.Discount ?? 0); //} //if (model.Tax != null) //{ // model.TotalAmount = model.TotalAmount + (model.Tax ?? 0); //} model.LineAmountSubTotal = model.Items.Sum(x => x.LineAmount); var count = await _invoiceRepository.getCount(); //await _invoiceRepository.AddAsync(InvoiceFactory.Create(model, _userId, items)); var invoice = InvoiceFactory.Create(model, _userId, count); await _invoiceRepository.AddAsync(invoice); await _unitOfWork.SaveChangesAsync(); var transaction = TransactionFactory.CreateByInvoice(invoice); await _transactionRepository.AddAsync(transaction); await _unitOfWork.SaveChangesAsync(); var itemsList = (model.Items.GroupBy(l => l.BankAccountId, l => new { l.BankAccountId, l.LineAmount }) .Select(g => new { GroupId = g.Key, Values = g.ToList() })).ToList(); foreach (var item in itemsList) { var id = item.GroupId; var amount = item.Values.Sum(x => x.LineAmount); var itemsData = TransactionFactory.CreateByInvoiceItemsAndTax(invoice, id, amount); await _transactionRepository.AddAsync(itemsData); await _unitOfWork.SaveChangesAsync(); } var taxlistList = (model.Items.GroupBy(l => l.TaxBankAccountId, l => new { l.TaxBankAccountId, l.TaxPrice }) .Select(g => new { GroupId = g.Key, Values = g.ToList() })).ToList(); foreach (var tax in taxlistList) { if (tax.GroupId > 0) { var id = tax.GroupId; var amount = tax.Values.Sum(x => x.TaxPrice); var taxData = TransactionFactory.CreateByInvoiceItemsAndTax(invoice, id, amount); await _transactionRepository.AddAsync(taxData); await _unitOfWork.SaveChangesAsync(); } } }
public async Task<string> BuildTransactionAsync(BigInteger amount, BigInteger fee, string fromAddress, BigInteger gasPrice, bool includeFee, Guid operationId, string toAddress) { #region Validation if (amount <= 0) { throw new ArgumentException("Amount should be greater then zero.", nameof(amount)); } if (fee <= 0) { throw new ArgumentException("Fee should be greater then zero.", nameof(fee)); } if (gasPrice <= 0) { throw new ArgumentException("Gas price should be greater then zero.", nameof(gasPrice)); } if (!await AddressValidator.ValidateAsync(fromAddress)) { throw new ArgumentException("Address is invalid.", nameof(fromAddress)); } if (!await AddressValidator.ValidateAsync(toAddress)) { throw new ArgumentException("Address is invalid.", nameof(toAddress)); } #endregion var operationTransactions = (await _transactionRepository.GetAllAsync(operationId)); var initialTransaction = operationTransactions.OrderBy(x => x.BuiltOn).FirstOrDefault(); if (initialTransaction != null) { return initialTransaction.TxData; } var nonce = await _ethereum.GetNextNonceAsync(fromAddress); var txData = _ethereum.BuildTransaction ( toAddress, amount, nonce, gasPrice, Constants.EtcTransferGasAmount ); await _transactionRepository.AddAsync(new BuiltTransactionDto { Amount = amount, BuiltOn = DateTime.UtcNow, Fee = fee, FromAddress = fromAddress, GasPrice = gasPrice, IncludeFee = includeFee, Nonce = nonce, OperationId = operationId, State = TransactionState.Built, ToAddress = toAddress, TxData = txData }); _chaosKitty.Meow(operationId); return txData; }