private static void Main(string[] args)
{
try
{
var repositoryConfig = new RepositoryConfiguration
{
ConnectionString = AppSettingHelper.GetDbConnection()
};
_persistenceFactory = new VakapayRepositoryMysqlPersistenceFactory(repositoryConfig);
var btcBusiness = new BitcoinBusiness.BitcoinBusiness(_persistenceFactory);
var rpc = new BitcoinRpc(AppSettingHelper.GetBitcoinNode(),
AppSettingHelper.GetBitcoinRpcAuthentication());
var transaction = rpc.FindTransactionByHash(args[0]);
Logger.Debug("BitcoinNotify =>> BTCTransactionModel: " + transaction.Data);
var transactionModel = BtcTransactionModel.FromJson(transaction.Data);
if (transactionModel.BtcTransactionDetailsModel != null &&
transactionModel.BtcTransactionDetailsModel.Length > 0)
{
foreach (var transactionModelDetail in transactionModel.BtcTransactionDetailsModel)
{
_walletBusiness = new WalletBusiness.WalletBusiness(_persistenceFactory);
if (transactionModelDetail.Category.Equals("receive"))
{
HandleNotifyDataReceiver(transactionModel, transactionModelDetail, btcBusiness);
}
else if (transactionModelDetail.Category.Equals("send"))
{
// if isExist(by address and transactionId) then update, else insert
HandleNotifyDataSend(transactionModel, transactionModelDetail, btcBusiness);
}
}
}
else
{
Logger.Debug("BitcoinNotify BtcTransactionDetailsModel is not exist");
}
}
catch (Exception e)
{
Logger.Error(e, "BitcoinNotify exception");
}
}
/// <summary>
/// HandleNotifyDataSend
/// </summary>
/// <param name="transactionModel"></param>
/// <param name="transactionModelDetail"></param>
/// <param name="btcBusiness"></param>
private static void HandleNotifyDataSend(BtcTransactionModel transactionModel,
BtcTransactionDetailModel transactionModelDetail, AbsBlockchainBusiness btcBusiness)
{
try
{
Logger.Debug("HandleNotifyDataSend start");
if (transactionModel.Confirmations > 0)
{
using (var bitCoinRawTransactionRepository = btcBusiness
.VakapayRepositoryFactory.GetBitcoinWithdrawTransactionRepository(btcBusiness.DbConnection))
{
var currentBtcWithdrawTransaction =
GetBtcWithdrawTransaction(bitCoinRawTransactionRepository, transactionModelDetail.Address,
transactionModel.Txid);
Logger.Debug(
"HandleNotifyDataSend =>> btcWithdrawTransaction: " + currentBtcWithdrawTransaction);
if (currentBtcWithdrawTransaction == null)
{
return;
}
Logger.Debug("HandleNotifyDataSend ==>> Update hash and time update ");
var currentTime = CommonHelper.GetUnixTimestamp();
if (currentBtcWithdrawTransaction.UserId == null)
{
currentBtcWithdrawTransaction.UserId = GetUserIdByAddress(transactionModelDetail.Address);
}
currentBtcWithdrawTransaction.BlockHash = transactionModel.BlockHash;
currentBtcWithdrawTransaction.UpdatedAt = currentTime;
bitCoinRawTransactionRepository.Update(currentBtcWithdrawTransaction);
}
}
else
{
Logger.Debug("HandleNotifyDataSend =>> confirm == 0");
}
}
catch (Exception e)
{
Logger.Error(e, "HandleNotifyDataSend exception");
}
}
/// <summary>
/// CreateNewBtcDepositTransaction
/// </summary>
/// <param name="transactionModel"></param>
/// <param name="transactionModelDetail"></param>
/// <param name="btcDepositTransactionRepository"></param>
/// <param name="currentTime"></param>
private static void CreateNewBtcDepositTransaction(BtcTransactionModel transactionModel,
BtcTransactionDetailModel transactionModelDetail,
IBitcoinDepositTransactionRepository btcDepositTransactionRepository, long currentTime
)
{
try
{
Logger.Debug("cretateNewBtcDepositTransaction ");
var btcDepositTransaction = new BitcoinDepositTransaction
{
Hash = transactionModel.Txid,
BlockNumber = 0,
BlockHash = transactionModel.BlockHash,
Amount = transactionModel.Amount,
FromAddress = "",
ToAddress = transactionModelDetail.Address,
Fee = 0,
Status = Status.STATUS_PENDING,
CreatedAt = currentTime,
UpdatedAt = currentTime
};
var userId = GetUserIdByAddress(transactionModelDetail.Address);
if (userId == null)
{
return;
}
var portfolioHistoryBusiness =
new PortfolioHistoryBusiness.PortfolioHistoryBusiness(_persistenceFactory, false);
portfolioHistoryBusiness.InsertWithPrice(userId);
btcDepositTransaction.UserId = userId;
Logger.Debug("cretateNewBtcDepositTransaction =>> btcDepositTransaction: " +
btcDepositTransaction.ToJson());
btcDepositTransactionRepository.Insert(btcDepositTransaction);
}
catch (Exception e)
{
Logger.Error(e, "cretateNewBtcDepositTransaction ");
}
}
public override void SyncUpdate()
{
lock (AsyncElectrumScheduleService.Transactions)
{
AsyncElectrumScheduleService.SetStatus("Сверка транзакций из Electrum [" + AsyncElectrumScheduleService.Transactions.Count + " элементов] с базой данных");
bool exist_new_tx = false;
foreach (TransactionWalletHistoryResponseClass TransactionWallet in AsyncElectrumScheduleService.Transactions.Where(x => x.confirmations > MinRequedCountConfirmations))
{
if (string.IsNullOrWhiteSpace(TransactionWallet.txid))
{
AsyncElectrumScheduleService.SetStatus("Прочитана транзакция из Electrum JSONRPC с пустым txid: " + TransactionWallet.ToString(), AbstractAsyncScheduler.StatusTypes.ErrorStatus);
AsyncElectrumScheduleService.SetStatus("Транзакция с пустым txid будет пропущена");
continue;
}
BtcTransactionModel btcTransaction;
try
{
btcTransaction = db.Set <BtcTransactionModel>().SingleOrDefault(x => x.TxId == TransactionWallet.txid);
}
catch (Exception e)
{
AsyncElectrumScheduleService.SetStatus("Ошибка поиска транзакции в БД SingleOrDefault(x => x.TxId == '" + TransactionWallet.txid + "')" + e.Message, AbstractAsyncScheduler.StatusTypes.ErrorStatus);
AsyncElectrumScheduleService.SetStatus("Ошибочная транзакция будет пропущена");
continue;
}
if (btcTransaction is null)
{
exist_new_tx = true;
AsyncElectrumScheduleService.SetStatus("Новая транзакция для записи в БД: " + TransactionWallet.ToString());
btcTransaction = new BtcTransactionModel()
{
TxId = TransactionWallet.txid,
Sum = glob_tools.GetDoubleFromString(TransactionWallet.value)
};
db.Add(btcTransaction);
db.SaveChanges();
foreach (TransactionWalletHistoryResponseOutputsClass TransactionOut in TransactionWallet.outputs.Where(x => AsyncElectrumScheduleService.ElectrumClient?.IsAddressMine(x.address)?.result == true))
{
AsyncElectrumScheduleService.SetStatus("Запись нового TxOut: " + TransactionOut.ToString());
BtcTransactionOutModel btcTransactionOut = new BtcTransactionOutModel()
{
BtcTransactionModelId = btcTransaction.Id,
Sum = glob_tools.GetDoubleFromString(TransactionOut.value),
Information = "txid:" + TransactionWallet.txid,
Address = TransactionOut.address,
IsMine = AsyncElectrumScheduleService.ElectrumClient.IsAddressMine(TransactionOut.address)?.result ?? false
};
db.Add(btcTransactionOut);
db.SaveChanges();
AsyncElectrumScheduleService.SetStatus("Поиск пользователя по BTC адресу > db.Users.SingleOrDefault(x => x.BitcoinAddress == '" + TransactionOut.address + "')");
UserModel user = db.Set <UserModel>().SingleOrDefault(x => x.BitcoinAddress == TransactionOut.address);
if (!(user is null))
{
AsyncElectrumScheduleService.SetStatus("Пользователь найден: " + user.ToString());
btcTransactionOut.UserId = user.Id;
db.Update(btcTransactionOut);
//
///int fiat_sum = (int)(btcTransactionOut.Sum * options.Value.CurrentBtcRate);
user.BalanceBTC += btcTransactionOut.Sum;
db.Update(user);
string notify = "Пополнение /balance +" + string.Format("{0:F8}", Math.Round(btcTransactionOut.Sum, 8)) + "=" + user.BalanceBTC + " BTC";
db.Add(new eCommerceJournalModel()
{
BaseObjectId = btcTransactionOut.Id,
TypeBaseObject = TypesBaseObject.TxOut,
ClientId = user.Id,
SumBTC = btcTransactionOut.Sum,
Information = notify
});
db.Add(new MessageModel()
{
Information = notify, SenderId = null, RecipientId = user.Id, NeedTelegramNotify = user.TelegramId != default
});
/// <summary>
/// handle notify transaction receiver
/// </summary>
/// <param name="transactionModel"></param>
/// <param name="transactionModelDetail"></param>
/// <param name="btcBusiness"></param>
private static void HandleNotifyDataReceiver(BtcTransactionModel transactionModel,
BtcTransactionDetailModel transactionModelDetail, AbsBlockchainBusiness btcBusiness)
{
try
{
Logger.Debug("HandleNotifiDataReceiver start");
using (var btcDepositTransactionRepository = btcBusiness.VakapayRepositoryFactory.GetBitcoinDepositTransactionRepository(btcBusiness.DbConnection))
{
Logger.Debug("HandleNotifiDataReceiver start1");
var currentBtcDepositTransaction = GetDepositTransaction(btcDepositTransactionRepository,
transactionModelDetail.Address, transactionModel.Txid);
Logger.Debug("HandleNotifiDataReceiver =>> currentBtcDepositTransaction: " +
currentBtcDepositTransaction);
var currentTime = CommonHelper.GetUnixTimestamp();
if (transactionModel.Confirmations == 0)
{
Logger.Debug("HandleNotifiDataReceiver with confirm = 0");
if (currentBtcDepositTransaction == null)
{
CreateNewBtcDepositTransaction(transactionModel, transactionModelDetail,
btcDepositTransactionRepository, currentTime);
}
else
{
// transaction is exist
Logger.Debug(
"HandleNotifiDataReceiver =>> BitcoinDepositTransaction is exist, don't create new data");
}
}
else
{
Logger.Debug("HandleNotifiDataReceiver with confirm > 0");
if (currentBtcDepositTransaction != null)
{
currentBtcDepositTransaction.BlockHash = transactionModel.BlockHash;
currentBtcDepositTransaction.Amount = transactionModel.Amount;
currentBtcDepositTransaction.Status = Status.STATUS_COMPLETED;
currentBtcDepositTransaction.UpdatedAt = currentTime;
btcDepositTransactionRepository.Update(currentBtcDepositTransaction);
}
else
{
CreateNewBtcDepositTransaction(transactionModel, transactionModelDetail,
btcDepositTransactionRepository, currentTime);
}
// update balance
_walletBusiness?.UpdateBalanceDeposit(transactionModelDetail.Address,
transactionModelDetail.Amount,
CryptoCurrency.BTC);
//insert new email data
CreateDataEmail(btcBusiness, transactionModelDetail);
}
}
}
catch (Exception e)
{
Logger.Error(e, "HandleNotifiDataReceiver exception");
}
}
