public VakacoinChainHelper(int blockInterval, VakacoinRpc rpcClient,
VakacoinBusiness vakacoinBusiness, IWalletBusiness walletBusiness,
SendMailBusiness.SendMailBusiness sendMailBusiness)
{
_blockInterval = blockInterval;
_rpcClient = rpcClient;
_vakacoinBusiness = vakacoinBusiness;
_walletBusiness = walletBusiness;
_sendMailBusiness = sendMailBusiness;
}
public WalletController(IWalletBusiness __IWalletBusiness, IAgencyBusiness __IAgencyBusiness,
IAccountBusiness __IAccountBusiness, ITransactionBusiness __ITransactionBusiness,
IWalletRepository __IWalletRepository, ITransactionHistoryBusiness __ITransactionHistoryBusiness)
{
_IWalletBusiness = __IWalletBusiness;
_IAgencyBusiness = __IAgencyBusiness;
_IAccountBusiness = __IAccountBusiness;
_ITransactionBusiness = __ITransactionBusiness;
_IWalletRepository = __IWalletRepository;
_ITransactionHistoryBusiness = __ITransactionHistoryBusiness;
}
public TransactionController(ITransactionBusiness __ITransactionBusiness, IWalletBusiness __IWalletBusiness,
IPayoutExportRepository __IPayoutExportRepository, ITransactionRepository __ITransactionRepository, INotificationBusiness __INotificationBusiness,
ITransactionHistoryBusiness __ITransactionHistoryBusiness, ITransactionService __ITransactionService, ICampaignService __ICampaignService,
IPaymentService _IPaymentService, IPayoutExportService __IPayoutExportService)
{
_ITransactionBussiness = __ITransactionBusiness;
_IWalletBusiness = __IWalletBusiness;
_IPayoutExportRepository = __IPayoutExportRepository;
_ITransactionRepository = __ITransactionRepository;
_INotificationBusiness = __INotificationBusiness;
_ITransactionHistoryBusiness = __ITransactionHistoryBusiness;
_ITransactionService = __ITransactionService;
_ICampaignService = __ICampaignService;
_paymentService = _IPaymentService;
_IPayoutExportService = __IPayoutExportService;
}
public MicroKolController(IAccountBusiness __IAccountBusiness, IAccountRepository __IAccountRepository,
IAccountCampaignChargeRepository __IAccountCampaignChargeRepository,
IAccountCampaignChargeBusiness __IAccountCampaignChargeBusiness, ICampaignBusiness __ICampaignBusiness,
ICampaignAccountRepository __ICampaignAccountRepository, ITransactionRepository __ITransactionRepository,
ITransactionBusiness __ITransactionBusiness, IWalletBusiness __IWalletBusiness, IWalletRepository __IWalletRepository,
INotificationBusiness __INotificationBusiness, IWalletService ___WalletService, INotificationService __INotificationService)
{
_IAccountBusiness = __IAccountBusiness;
_IAccountRepository = __IAccountRepository;
_IAccountCampaignChargeRepository = __IAccountCampaignChargeRepository;
_IAccountCampaignChargeBusiness = __IAccountCampaignChargeBusiness;
_ICampaignBusiness = __ICampaignBusiness;
_ICampaignAccountRepository = __ICampaignAccountRepository;
_ITransactionRepository = __ITransactionRepository;
_ITransactionBusiness = __ITransactionBusiness;
_IWalletBusiness = __IWalletBusiness;
_IWalletRepository = __IWalletRepository;
_INotificationBusiness = __INotificationBusiness;
_WalletService = ___WalletService;
_INotificationService = __INotificationService;
}
public virtual async Task <ReturnObject> ScanBlockAsync <TWithDraw, TDeposit, TBlockResponse, TTransaction>(
string networkName,
IWalletBusiness wallet,
IRepositoryBlockchainTransaction <TWithDraw> withdrawRepoQuery,
IRepositoryBlockchainTransaction <TDeposit> depositRepoQuery,
IBlockchainRpc rpcClass)
where TWithDraw : BlockchainTransaction
where TDeposit : BlockchainTransaction
where TBlockResponse : EthereumBlockResponse
where TTransaction : EthereumTransactionResponse
{
try
{
int lastBlock = -1;
int blockNumber = -1;
//Get lastBlock from last time
int.TryParse(
CacheHelper.GetCacheString(String.Format(RedisCacheKey.KEY_SCANBLOCK_LASTSCANBLOCK,
networkName)), out lastBlock);
if (lastBlock < 0)
{
lastBlock = 0;
}
//get blockNumber:
var _result = rpcClass.GetBlockNumber();
if (_result.Status == Status.STATUS_ERROR)
{
throw new Exception("Cant GetBlockNumber");
}
if (!int.TryParse(_result.Data.ToString(), out blockNumber))
{
throw new Exception("Cant parse block number");
}
//Get list of new block that have transactions
if (lastBlock >= blockNumber)
{
lastBlock = blockNumber;
}
Console.WriteLine("SCAN FROM " + lastBlock + "___" + blockNumber);
List <TBlockResponse> blocks = new List <TBlockResponse>();
for (int i = lastBlock; i <= blockNumber; i++)
{
if (i < 0)
{
continue;
}
_result = rpcClass.GetBlockByNumber(i);
if (_result.Status == Status.STATUS_ERROR)
{
return(_result);
}
if (_result.Data == null)
{
continue;
}
TBlockResponse _block = JsonHelper.DeserializeObject <TBlockResponse>(_result.Data.ToString());
if (_block.TransactionsResponse.Length > 0)
{
blocks.Add(_block);
}
}
CacheHelper.SetCacheString(String.Format(RedisCacheKey.KEY_SCANBLOCK_LASTSCANBLOCK, networkName),
blockNumber.ToString());
if (blocks.Count <= 0)
{
throw new Exception("no blocks have transaction");
}
//Get done,List<> blocks now contains all block that have transaction
//check Transaction and update:
//Search transactions which need to scan:
var withdrawPendingTransactions = withdrawRepoQuery.FindTransactionsNotCompleteOnNet();
//Scan all block and check Withdraw transaction:
Console.WriteLine("Scan withdrawPendingTransactions");
if (withdrawPendingTransactions.Count > 0)
{
foreach (TBlockResponse _block in blocks)
{
if (withdrawPendingTransactions.Count <= 0)
{
//SCAN DONE:
break;
}
for (int i = withdrawPendingTransactions.Count - 1; i >= 0; i--)
{
BlockchainTransaction _currentPending = withdrawPendingTransactions[i];
EthereumTransactionResponse _trans =
_block.TransactionsResponse.SingleOrDefault(x => x.Hash.Equals(_currentPending.Hash));
int _blockNumber = -1;
int _fee = 0;
if (_trans != null)
{
_trans.BlockNumber.HexToInt(out _blockNumber);
if (_trans.Fee != null)
{
_trans.Fee.HexToInt(out _fee);
}
Console.WriteLine("HELLO " + _currentPending.Hash);
_currentPending.BlockNumber = _blockNumber;
_currentPending.Fee = _fee;
_currentPending.UpdatedAt = (int)CommonHelper.GetUnixTimestamp();
// _currentPending.Status = Status.StatusCompleted;
// _currentPending.InProcess = 0;
Console.WriteLine("CaLL UPDATE");
portfolioHistoryBusiness.InsertWithPrice(_currentPending.UserId);
withdrawRepoQuery.Update((TWithDraw)_currentPending);
withdrawPendingTransactions.RemoveAt(i);
}
}
}
}
Console.WriteLine("Scan withdrawPendingTransactions Done");
//check wallet balance and update
foreach (TBlockResponse _block in blocks)
{
foreach (EthereumTransactionResponse _trans in _block.TransactionsResponse)
{
string _toAddress = _trans.To;
string _fromAddress = _trans.From;
if (!wallet.CheckExistedAddress(_toAddress, networkName))
{
//logger.Info(to + " is not exist in Wallet!!!");
continue;
}
else
{
//Console.WriteLine("value" + _trans.value);
int _transaValue = 0;
if (_trans.Value.HexToInt(out _transaValue))
{
var userID = "";
// portfolioHistoryBusiness.InsertWithPrice(_trans.i);
wallet.UpdateBalanceDeposit(_toAddress, (Decimal)_transaValue, networkName);
}
}
}
}
return(new ReturnObject
{
Status = Status.STATUS_COMPLETED,
Message = "Scan done"
});
}
catch (Exception e)
{
return(new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = e.Message
});
}
}
